1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [விமர்சனம்] [வினாடி வினா 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi ரோஸ், டாமி MacWilliam, லூகாஸ் Freitas, ஜோசப் ஆங்] [ஹார்வர்ட் பல்கலைக்கழகம்]

3
00:00:05,000 --> 00:00:08,000
>> [இந்த CS50 உள்ளது.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> ஏய், எல்லோரும்.

5
00:00:10,000 --> 00:00:15,000
இந்த புதன் நடைபெற்று வரும் வினாடி வினா 0, மதிப்புரை அமர்வு வரவேற்கிறது.

6
00:00:15,000 --> 00:00:19,000
நாம் இன்று செய்ய போகிறோம் என்ன, நான், 3 மற்ற டிஎஃப்எஸ் இருக்கிறேன்

7
00:00:19,000 --> 00:00:24,000
மற்றும் ஒன்றாக நாம் இதுவரை போக்கில் செய்துவிட்டேன் என்ன ஒரு ஆய்வு மூலம் செல்ல போகிறோம்.

8
00:00:24,000 --> 00:00:27,000
இது 100% விரிவான இருக்க போவதில்லை, ஆனால் அதை நீங்கள் ஒரு நல்ல யோசனை கொடுக்க வேண்டும்

9
00:00:27,000 --> 00:00:31,000
நீங்கள் ஏற்கனவே கீழே உள்ளது என்ன என்ன நீங்கள் இன்னும் புதன் முன் படிக்க வேண்டும்.

10
00:00:31,000 --> 00:00:34,000
நாம் சேர்ந்து போகிறோம் மற்றும், கேள்விகளை உங்கள் கையை உயர்த்தி கொள்ளலாம்

11
00:00:34,000 --> 00:00:38,000
ஆனால் நாங்கள் அந்த நேரத்தில் ஒரு சிறிது வேண்டும் என்று மனதில் வைத்து முடிவு

12
00:00:38,000 --> 00:00:41,000
நாம் பொது கேள்விகள் செய்ய ஓய்வு-ஒரு சில நிமிடங்களுக்கு மூலம் கிடைக்கும் என்றால்,

13
00:00:41,000 --> 00:00:47,000
அதனால் மனதில் என்று வைத்து, மற்றும் நாம் வீக் 0 ஆரம்பத்தில் தொடங்க போகிறோம்.

14
00:00:47,000 --> 00:00:50,000
>> நாம் முன்னர் [0 விமர்சனம் க்விஸ்!] [பாகம் 0] [Lexi ரோஸ்] ஆனால் நாம் பற்றி பேச என்று

15
00:00:50,000 --> 00:00:53,000
வினாடி வினா மற்றும் தளவாடங்கள்.

16
00:00:53,000 --> 00:00:55,000
>> [லாஜிஸ்டிக்ஸ்] [வினாடி வினா விரிவுரை பதிலாக புதன் 10/10 அன்று நடைபெறும்]

17
00:00:55,000 --> 00:00:57,000
>> [(விவரங்களுக்கு http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf காண்க)] இது புதன், அக்டோபர் 10 ஆம் தேதி ஆகும்.

18
00:00:57,000 --> 00:01:00,000
>> இந்த புதன், மற்றும் நீங்கள் இங்கே இந்த URL க்கு சென்றால்,

19
00:01:00,000 --> 00:01:03,000
இது கூட ஒரு இணைப்பை CS50.net-அங்கு 'கள் பெறப்படவில்லை என்பது,

20
00:01:03,000 --> 00:01:06,000
நீங்கள் அடிப்படையில் எங்கே போவது பற்றி தகவல் பார்க்க முடியும்

21
00:01:06,000 --> 00:01:10,000
உங்கள் கடைசி பெயர் அல்லது பள்ளி தொடர்பு அதேபோல

22
00:01:10,000 --> 00:01:14,000
அதை பற்றி சரியாக புதிர் நீ போகிறோம் என்று கவர் மற்றும் கேள்விகள் வகைகள் என்ன சொல்கிறது.

23
00:01:14,000 --> 00:01:19,000
நீங்கள் பகுதியில் வினாடி வினா ஒரு ஆய்வு செய்ய ஒரு வாய்ப்பு வேண்டும் என்பதை நினைவில் கொள்ளுங்கள்,

24
00:01:19,000 --> 00:01:21,000
எனவே உங்கள் டிஎஃப்எஸ், சில நடைமுறை சிக்கல்கள் பற்றி நான்

25
00:01:21,000 --> 00:01:29,000
என்று நீங்கள் இன்னும் வினாடி வினா எழுந்து படிக்க வேண்டும், அங்கு பார்க்க மற்றொரு நல்ல வாய்ப்பு.

26
00:01:29,000 --> 00:01:32,000
பிட்ஸ் 'n' பைட்டுகள் கொண்ட ஆரம்பத்தில் ஆரம்பிக்கலாம்.

27
00:01:32,000 --> 00:01:35,000
ஒரு பிட் ஒரு 0 அல்லது 1, ஞாபகம்

28
00:01:35,000 --> 00:01:38,000
மற்றும் ஒரு பைட் அந்த பிட்கள் 8 தொகுப்பு ஆகும்.

29
00:01:38,000 --> 00:01:42,000
சரி இங்கே பிட்கள் இந்த தொகுப்பு பார்க்க போகலாம்.

30
00:01:42,000 --> 00:01:44,000
நாம் அங்கு எவ்வளவு பிட்கள் கண்டுபிடிக்க முடியும்.

31
00:01:44,000 --> 00:01:48,000
நாம் எண்ணி அங்கு அவர்கள் 8, எட்டு 0 அல்லது 1 அலகுகள் தான் இருக்கிறது.

32
00:01:48,000 --> 00:01:51,000
மற்றும் முதல் 8 பிட்கள், 1 பைட் என்று, அங்கே

33
00:01:51,000 --> 00:01:53,000
மற்றும் ஒரு அறுபதின்ம மாற்ற வேண்டும்.

34
00:01:53,000 --> 00:01:58,000
அறுபதின்ம அடிப்படை 16, மற்றும் அதை மாற்ற அழகாக எளிதாக

35
00:01:58,000 --> 00:02:01,000
பைனரி ஒரு எண், இது அறுபதின்ம ஒரு எண், என்று உள்ளது.

36
00:02:01,000 --> 00:02:04,000
நாம் அனைவரும் நாம், 4 குழுக்கள் பார் உள்ளது

37
00:02:04,000 --> 00:02:07,000
நாம் சரியான அறுபதின்ம இலக்க ஐக்கிய அவற்றை மாற்ற.

38
00:02:07,000 --> 00:02:11,000
நாம் 0011, 4 உரிமையை மிக குழு தொடங்க.

39
00:02:11,000 --> 00:02:16,000
அதனால் சேர்ந்து 3 செய்கிறது என்று, ஒரு 1 மற்றும் ஒரு 2 இருக்க போகிறது.

40
00:02:16,000 --> 00:02:19,000
பின்னர் 4 மற்ற தொகுதி பார்க்க வேண்டும்.

41
00:02:19,000 --> 00:02:24,000
1101. என்று ஒரு 1, 4 ஒன்று 8 இருக்க போகிறது.

42
00:02:24,000 --> 00:02:28,000
ஒன்றாக என்று டி வகையில், 13 ஆக போகிறது

43
00:02:28,000 --> 00:02:32,000
நாம் அறுபதின்ம நாம் வெறும் 9 வழியாக 0 போக கூடாது என்று ஞாபகம்.

44
00:02:32,000 --> 00:02:36,000
நாம், மிக 9 பின்னர், எஃப் மூலம் ஒரு 10 ஒத்துள்ளது 0 போக,

45
00:02:36,000 --> 00:02:40,000
எஃப் 15 எங்கே 11 பி, பயன்படுத்தப்படுகிறது.

46
00:02:40,000 --> 00:02:44,000
இங்கு 13, ஒரு D ஆகும்

47
00:02:44,000 --> 00:02:49,000
அதை நாம் செய்ய அனைத்து நாம் உண்மையில் தசம மாற்ற

48
00:02:49,000 --> 00:02:52,000
2 ஒரு சக்தியாக ஒவ்வொரு நிலையில் சிகிச்சை.

49
00:02:52,000 --> 00:02:58,000
என்று ஒரு 1, 2, ஒரு பூஜ்யம் 4s, பூஜ்யம் 8s, ஒரு 16, பயன்படுத்தப்படுகிறது, அது

50
00:02:58,000 --> 00:03:03,000
அது உங்கள் தலையில் கணக்கிட கொஞ்சம் கடினமாக உள்ளது, ஆனால் நாம் அடுத்த ஸ்லைடு போனால்

51
00:03:03,000 --> 00:03:05,000
நாம் பதில் காண முடியும்.

52
00:03:05,000 --> 00:03:09,000
>> அடிப்படையில் நாம், இடது வலது இருந்து முழுவதும் போகிறோம்

53
00:03:09,000 --> 00:03:14,000
நாங்கள் 2 தொடர்புடைய சக்தி ஒவ்வொரு இலக்க ஐக்கிய பெருக்குவதன்.

54
00:03:14,000 --> 00:03:19,000
மேலும், நினைவில் அறுபதின்ம நாம் ஆரம்பத்தில் 0x இந்த எண்களை குறிக்க

55
00:03:19,000 --> 00:03:23,000
எனவே நாம் ஒரு தசம எண்ணை அதை குழப்ப வேண்டாம்.

56
00:03:23,000 --> 00:03:29,000
ஆனால் தொடர்ந்து, இந்த, ஒரு ஆஸ்கி அட்டவணை உள்ளது

57
00:03:29,000 --> 00:03:35,000
நாம் ஆஸ்கி பயன்படுத்த என்ன எழுத்துகள் இருந்து எண் மதிப்புகள் மேப்பிங் ஆகும்.

58
00:03:35,000 --> 00:03:39,000
குறியாக்கவியல் pset நினைவிருக்கிறதா நாம் ஆஸ்கி அட்டவணை விரிவான பயன்படுத்தி

59
00:03:39,000 --> 00:03:43,000
குறியாக்கவியல் பல்வேறு முறைகள் பயன்படுத்த,

60
00:03:43,000 --> 00:03:47,000
பல்வேறு கடிதங்கள் மாற்ற சீசர் மற்றும் வைஜெனேர் மறைக்குறியீடு,

61
00:03:47,000 --> 00:03:52,000
பயனர் கொடுக்கப்பட்ட முக்கிய படி ஒரு சரம் இல்.

62
00:03:52,000 --> 00:03:56,000
அது ASCII, கணித சிறிது பார்க்கிறேன்.

63
00:03:56,000 --> 00:04:02,000
கே என்று எழுத்து வடிவம், 'பி' இல் + 1 விரும்புவது,

64
00:04:02,000 --> 00:04:07,000
மற்றும் '5 '≠ 5 நினைவில்.

65
00:04:07,000 --> 00:04:10,000
எப்படி சரியாக நாம் அந்த 2 வடிவங்கள் இடையே மாற்ற வேண்டும்?

66
00:04:10,000 --> 00:04:13,000
அது உண்மையில் மிகவும் கடினமானது அல்ல.

67
00:04:13,000 --> 00:04:16,000
5 பெறுவதற்காக நாம் '0 கழித்து '

68
00:04:16,000 --> 00:04:20,000
ஏனெனில் '0 இடையே 5 இடங்களில் உள்ளன 'மற்றும் '5.'

69
00:04:20,000 --> 00:04:23,000
நாம் வெறும் 0 சேர்க்க வேறு வழி செல்ல வேண்டும்,

70
00:04:23,000 --> 00:04:25,000
எனவே இது வழக்கமான கூட்டல் போன்ற வகையான தான்.

71
00:04:25,000 --> 00:04:29,000
நான் ஏதோ அதை சுற்றி மேற்கோள் போது அது ஒரு பாத்திரம் என்று நினைவில்

72
00:04:29,000 --> 00:04:37,000
இதனால் ஆஸ்கி அட்டவணையில் ஒரு மதிப்பு ஒத்துள்ளது.

73
00:04:37,000 --> 00:04:40,000
மேலும் பொது கணினி அறிவியல் தலைப்புகள் நகரும்.

74
00:04:40,000 --> 00:04:43,000
நாம் நிகழ்ச்சிகளை பயன்படுத்த என்ன ஒரு வழிமுறையாகும் மற்றும் எப்படி கற்று

75
00:04:43,000 --> 00:04:45,000
வழிமுறைகளை செயல்படுத்த.

76
00:04:45,000 --> 00:04:48,000
வழிமுறைகள் சில உதாரணங்கள் போன்ற மிகவும் எளிமையான ஒன்று தான்

77
00:04:48,000 --> 00:04:51,000
ஒரு எண்ணை கூட அல்லது வித்தியாசமாக இருக்கிறது சரிபார்ப்பதன்.

78
00:04:51,000 --> 00:04:54,000
என்று நாம் 2 எண் mod மற்றும் விளைவாக 0 உள்ளதா என்பதை அறியவும் நினைவில்.

79
00:04:54,000 --> 00:04:57,000
எனவே, அது கூட இல்லை. இல்லை என்றால், அது மாதிரி தான்.

80
00:04:57,000 --> 00:04:59,000
மற்றும் ஒரு உண்மையிலேயே அடிப்படை வழிமுறையின் ஒரு எடுத்துக்காட்டு.

81
00:04:59,000 --> 00:05:02,000
>> மேலும் இதில் ஒரு கொஞ்சம் இரும தேடல் இருக்கிறது,

82
00:05:02,000 --> 00:05:05,000
இதில் நாம் மீளாய்வு கூட்டத்தில் பிறகு போகலாம்.

83
00:05:05,000 --> 00:05:09,000
மற்றும் நிரலாக்க நாம் ஒரு வழிமுறையை எடுத்து பயன்படுத்த சொல்

84
00:05:09,000 --> 00:05:15,000
இது கணினி குறியீடு மாற்றப்படுகிறது படிக்க முடியும்.

85
00:05:15,000 --> 00:05:20,000
நிரலாக்க 2 எடுத்துக்காட்டுகள், கீறல் இல்லை

86
00:05:20,000 --> 00:05:22,000
இதில் நாம் வீக் 0 செய்தது என்ன.

87
00:05:22,000 --> 00:05:25,000
நாம் உண்மையில் குறியீடு அவுட் தட்டச்சு செய்ய கூட அதை செயல்படுத்த ஒரு வழி

88
00:05:25,000 --> 00:05:29,000
எண்கள் 1-10 அச்சிடுதல் இந்த வழிமுறை,,

89
00:05:29,000 --> 00:05:32,000
இங்கு நாம் C நிரலாக்க மொழியில் அதே.

90
00:05:32,000 --> 00:05:41,000
இவை வெவ்வேறு மொழிகளை அல்லது தொடரியல் எழுதப்பட்ட, செயல்படவில்லை சமமானதாக இருக்கும்.

91
00:05:41,000 --> 00:05:44,000
நாம், பூலியன் வெளிப்பாடுகள் பற்றி கற்று

92
00:05:44,000 --> 00:05:48,000
மற்றும் ஒரு பூலியன், உண்மை அல்லது தவறான ஒன்று என்று ஒரு மதிப்பு இருக்கிறது

93
00:05:48,000 --> 00:05:51,000
இங்கு oftentimes பூலியன் வெளிப்பாடுகள்

94
00:05:51,000 --> 00:05:55,000
நீங்கள் (x ≤ 5), நிலைமைகளை உள்ளே போக,

95
00:05:55,000 --> 00:06:00,000
நன்றாக, நாம் ஏற்கனவே அந்த நிலையில் உண்மையான மதிப்பீடு செய்ய போகிறது x = 5, அதனால் அமைக்க.

96
00:06:00,000 --> 00:06:03,000
இது உண்மை என்றால், அதை குறியீடு நிலையில் கீழே இருக்கிறது

97
00:06:03,000 --> 00:06:08,000
கணினி மூலம் மதிப்பீடு போகிறது, அதனால் சரம் அச்சிடப்பட்ட போகிறது

98
00:06:08,000 --> 00:06:12,000
நிலையான வெளியீடு, மற்றும் கால நிலை

99
00:06:12,000 --> 00:06:16,000
என்று அறிக்கை அடைப்புக்குறிக்குள் உள்ளே என்ன குறிக்கிறது.

100
00:06:16,000 --> 00:06:20,000
எல்லா ஆபரேட்டர்களும் நினைவில்.

101
00:06:20,000 --> 00:06:26,000
| நாம் முயற்சிக்கும் போது இணைக்க 2 அல்லது அதற்கு மேற்பட்ட நிலைமைகள், | அது && மற்றும் நினைவில்

102
00:06:26,000 --> 00:06:30,000
== இல்லை = 2 விஷயங்களை சமமாக சோதிக்க.

103
00:06:30,000 --> 00:06:36,000
== ஒரு பூலியன் ஆபரேட்டர் அதேசமயம் = வேலையாக என்று ஞாபகம்.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ பின்னர் இறுதி 2 சுய விளக்க உள்ளனர்.

105
00:06:41,000 --> 00:06:45,000
இங்கே பூலியன் தருக்கம் ஒரு பொது ஆய்வு.

106
00:06:45,000 --> 00:06:48,000
மற்றும் பூலியன் வெளிப்பாடுகள், சுழல்கள் கூட முக்கியம்

107
00:06:48,000 --> 00:06:50,000
இதில் நாம் இப்போது போகலாம்.

108
00:06:50,000 --> 00:06:56,000
நாங்கள் போது, ஐந்து, CS50 இதுவரை சுழல்கள் பற்றி 3 வகையான கற்று, மற்றும் அதே நேரத்தில் செய்ய.

109
00:06:56,000 --> 00:06:59,000
அது எனக்கு முக்கியம் என்று பெரும்பாலான நோக்கங்களுக்காக போது

110
00:06:59,000 --> 00:07:02,000
நாம் உண்மையில் பொதுவாக வளைய எந்த வகை பயன்படுத்தலாம்

111
00:07:02,000 --> 00:07:06,000
நோக்கங்களுக்காக அல்லது பொதுவான முறைகள் சில வகைகள் உள்ளன

112
00:07:06,000 --> 00:07:09,000
குறிப்பாக இந்த சுழல்கள் ஒரு அழைப்பு என்று நிகழ்ச்சிகளில்

113
00:07:09,000 --> 00:07:13,000
அது மிக திறமையான அல்லது அந்த வழியில் அதை குறியீட்டை நேர்த்தியான.

114
00:07:13,000 --> 00:07:18,000
அது இந்த சுழல்கள் ஒவ்வொரு பெரும்பாலும் பயன்படுத்தப்படும் போக்கை என்ன செல்லலாம்.

115
00:07:18,000 --> 00:07:21,000
>> ஒரு வட்டத்திற்கு நாம் பொதுவாக ஏற்கனவே நாம் மீண்டும் கூறு வேண்டும் எத்தனை முறை தெரியும்.

116
00:07:21,000 --> 00:07:24,000
என்று நாம் நிலையில் வைத்து என்ன.

117
00:07:24,000 --> 00:07:28,000
இன்னும், நான் = 0, நான் <10, எடுத்துக்காட்டாக.

118
00:07:28,000 --> 00:07:31,000
நாம் ஏற்கனவே நாம் ஒன்று 10 முறை செய்ய வேண்டும் என்பது எனக்கு தெரியும்.

119
00:07:31,000 --> 00:07:34,000
இப்போது, ஒரு லூப், பொதுவாக நாம் அவசியமில்லை

120
00:07:34,000 --> 00:07:36,000
நாம் வளைய இயக்க வேண்டும் எத்தனை முறை தெரியும்.

121
00:07:36,000 --> 00:07:39,000
ஆனால் நாங்கள் அதை விரும்பவில்லை என்று நிபந்தனை ஒருவித தெரியும்

122
00:07:39,000 --> 00:07:41,000
எப்போதும் உண்மையாக இருக்கும் அல்லது எப்போதும் தவறான இருக்கும்.

123
00:07:41,000 --> 00:07:44,000
எடுத்துக்காட்டாக, அதே அமைக்கப்படுகிறது.

124
00:07:44,000 --> 00:07:46,000
நாம் ஒரு பூலியன் மாறி சொல்ல.

125
00:07:46,000 --> 00:07:48,000
அது உண்மைதான் என்றாலும் நாம் குறியீடு மதிப்பீடு செய்ய வேண்டும்,

126
00:07:48,000 --> 00:07:52,000
எனவே சற்று நீடிக்கவும், லூப் ஒரு விட பொது சிறிது,

127
00:07:52,000 --> 00:07:55,000
ஆனால் சுழற்சி எந்த ஒரு நேரத்தில் வளைய வேண்டும்.

128
00:07:55,000 --> 00:08:00,000
இறுதியாக, அதை போது இப்போதே புரிந்து கொள்ள trickiest இருக்கலாம் சுழல்கள்,,

129
00:08:00,000 --> 00:08:04,000
நாம் முதல் குறியீடு மதிப்பீடு செய்ய வேண்டும் என்று அடிக்கடி பயன்படுத்தப்படுகின்றன

130
00:08:04,000 --> 00:08:06,000
முதல் முறையாக முன் நாம் நிலையில் சரிபார்க்கவும்.

131
00:08:06,000 --> 00:08:09,000
ஒரு ஒரு பொதுவான பயன் வழக்கு செய்ய போது சுழற்சி

132
00:08:09,000 --> 00:08:12,000
நீங்கள் பயனர் உள்ளீடு பெற வேண்டும் போது, மற்றும் நீங்கள் பயனர் கேட்க வேண்டும் என்று

133
00:08:12,000 --> 00:08:15,000
உள்ளீடு குறைந்த பட்சம் ஒரு முறை, ஆனால் அவர்கள் நல்ல உள்ளீடு தரவில்லை என்றால் இப்போதே

134
00:08:15,000 --> 00:08:18,000
அவர்கள் உங்களுக்கு நல்ல உள்ளீடு கொடுக்க வரை அவர்களை கேட்டு கொள்ள வேண்டும்.

135
00:08:18,000 --> 00:08:21,000
அதே நேரத்தில் வளைய ஒரு மிக பொதுவான பயன்பாடு, என்று தான்

136
00:08:21,000 --> 00:08:23,000
மற்றும் அது இந்த சுழல்கள் உண்மையான கட்டமைப்பை பார்த்து விட்டு.

137
00:08:23,000 --> 00:08:27,000
அவர்கள் பொதுவாக எப்போதும் இந்த முறை பின்பற்ற முனைகின்றன.

138
00:08:27,000 --> 00:08:30,000
>> உள்ளே ஒரு வட்டத்திற்கு நீங்கள் 3 பாகங்கள் உண்டு:

139
00:08:30,000 --> 00:08:35,000
தொடக்க, பொதுவாக ஏதாவது போன்ற முழு எண்ணாக நான் எண்ணி எங்கே = 0,

140
00:08:35,000 --> 00:08:40,000
இந்த நிலையில் நாம் இன்னும் வைத்திருக்கும் வரை லூப் இந்த இயக்க சொல்ல விரும்பும் நிலையில்,

141
00:08:40,000 --> 00:08:44,000
நாம் அதிகப்படுத்த எப்படி இது நான் இறுதியாக பின்னர் <10, மற்றும், மேம்படுத்தல் போன்ற

142
00:08:44,000 --> 00:08:47,000
வட்டத்திற்கு ஒவ்வொரு கட்டத்திலும் எதிர்ப்பு மாறி.

143
00:08:47,000 --> 00:08:50,000
அங்கு பார்க்க ஒரு பொதுவான விஷயம், தான் நான் + உள்ளது

144
00:08:50,000 --> 00:08:52,000
இதில் 1 ஒவ்வொரு முறை நான் அதிகப்படுத்த வேண்டும்.

145
00:08:52,000 --> 00:08:55,000
நீங்கள், நான் + = 2 போன்ற ஏதாவது செய்ய முடியும்

146
00:08:55,000 --> 00:08:58,000
இது நான் உங்களை வளையத்தின் வழியாக செல்லும் ஒவ்வொரு முறையும் 2 சேர்க்க வேண்டும்.

147
00:08:58,000 --> 00:09:03,000
பின்னர் இதை தான் உண்மையில் வளைய பகுதியாக இயங்கும் எந்த குறியீடு குறிக்கிறது.

148
00:09:03,000 --> 00:09:09,000
மற்றும் ஒரு லூப், இந்த நேரத்தில் நாம் உண்மையில், சுழற்சி வெளியே துவக்கும் வேண்டும்

149
00:09:09,000 --> 00:09:12,000
எனவே உதாரணமாக, நாம் நான் குறிப்பிட்டது சுழற்சி அதே வகை செய்ய முயற்சிக்கும் சொல்கிறேன்.

150
00:09:12,000 --> 00:09:16,000
நாம் எண்ணாக நான் = 0 வளைய தொடங்கும் முன்பு கூறுவேன்.

151
00:09:16,000 --> 00:09:20,000
நான் <10 இந்த நிலையில் நாம் என்ன செய்ய முடியும்

152
00:09:20,000 --> 00:09:22,000
முன் குறியீடு எனவே அதே தொகுதி,

153
00:09:22,000 --> 00:09:26,000
இந்த நேரத்தில் உதாரணமாக குறியீடு மேம்படுத்தல் பகுதியாக, நான் + +

154
00:09:26,000 --> 00:09:29,000
உண்மையில் வளைய உள்ளே செல்லும்.

155
00:09:29,000 --> 00:09:33,000
இறுதியாக, ஒரு, அது போது சுழற்சி ஒத்த வரை செய்ய,

156
00:09:33,000 --> 00:09:36,000
ஆனால் நாம் குறியீடு ஒருமுறை மதிப்பீடு என்று நினைவில் இல்லை

157
00:09:36,000 --> 00:09:40,000
நிலைமையை சரி முன், அது மிக அதிக அர்த்தமுள்ளதாக

158
00:09:40,000 --> 00:09:44,000
நீங்கள் கீழே மேல் வரிசையில் பாருங்கள். என்றால்

159
00:09:44,000 --> 00:09:49,000
ஒரு நீங்கள் கூட அதே நிலையை பார் முன் வளைய குறியீடு மதிப்பீடு போது செய்ய,

160
00:09:49,000 --> 00:09:55,000
ஒரு வட்டத்திற்கு அதேசமயம், இது முதல் சரிபார்க்கிறது.

161
00:09:55,000 --> 00:09:59,000
அறிக்கைகள் மற்றும் மாறிகள்.

162
00:09:59,000 --> 00:10:04,000
நாம் ஒரு புதிய மாறி உருவாக்க வேண்டும் போது நாம் முதலில் துவக்க வேண்டும்.

163
00:10:04,000 --> 00:10:07,000
>> எடுத்துக்காட்டாக, int பட்டியில், மாறி பட்டியில் துவக்கும்

164
00:10:07,000 --> 00:10:10,000
ஆனால் அது இப்போது பார் மதிப்பு என்ன அதனால், அது ஒரு மதிப்பு கொடுக்க கூடாது?

165
00:10:10,000 --> 00:10:12,000
நாம் தெரியாது.

166
00:10:12,000 --> 00:10:14,000
இது, முன்னர் அங்கு நினைவகத்தில் சேமிக்கப்படும் என்று சில குப்பை மதிப்பு இருக்க முடியும்

167
00:10:14,000 --> 00:10:16,000
நாம் அது மாறி பயன்படுத்த வேண்டாம்

168
00:10:16,000 --> 00:10:19,000
நாம் உண்மையில் அது ஒரு மதிப்பு கொடுக்க, வரை

169
00:10:19,000 --> 00:10:21,000
நாம் இங்கே அதை அறிவிக்க.

170
00:10:21,000 --> 00:10:24,000
நாம் அது கீழே 42 இருக்கும் துவக்க.

171
00:10:24,000 --> 00:10:28,000
இப்போது, நிச்சயமாக, நாம் இந்த ஒரு வரியில் மீது, முழு எண்ணாக பட்டியில் = 42 செய்திருக்க வேண்டும் முடியாது என்று எனக்கு தெரியும்.

172
00:10:28,000 --> 00:10:30,000
ஆனால் வெறும், மீது போகிறாய் என்று என்று பல படிநிலைகளை துடைக்க வேண்டும்

173
00:10:30,000 --> 00:10:34,000
பிரகடனத்தை மற்றும் துவக்குதலை இங்கே தனித்தனியாக என்ன நடக்கிறது உள்ளன.

174
00:10:34,000 --> 00:10:38,000
, அது அடுத்த ஒரு, முழு எண்ணாக பஜ் = பட்டியில் + 1, ஒரு படி மீது நடக்கும், மற்றும்

175
00:10:38,000 --> 00:10:44,000
இந்த குறியீடு தொகுதி இறுதியில் கீழே இந்த அறிக்கை, அந்த அதிகரிக்கும் பஜ்,

176
00:10:44,000 --> 00:10:48,000
நாம் பஜ் மதிப்பை அச்சிட இருந்தன இருந்தால்,, அது 44 இருக்கும் என

177
00:10:48,000 --> 00:10:52,000
நாம், அறிவிக்கலாம், மற்றும் 1> பட்டியில் இருக்க வேண்டும், அது துவக்க, ஏனெனில்

178
00:10:52,000 --> 00:10:58,000
மற்றும், பின்னர் நாம் உடன் இன்னும் ஒருமுறை, அது அதிகப்படுத்த + +.

179
00:10:58,000 --> 00:11:02,000
நாம் இந்த அழகாக சுருக்கமாக க்கும் மேற்பட்ட சென்றார், ஆனால், அது ஒரு பொது வேண்டும் நல்லதாயிற்று

180
00:11:02,000 --> 00:11:04,000
த்ரெட்களும் மற்றும் நிகழ்வுகளை இருக்கும் என்ன பற்றிய புரிந்து.

181
00:11:04,000 --> 00:11:06,000
நாம் முக்கியமாக, ஸ்க்ராட்ச் உள்ள இந்த did

182
00:11:06,000 --> 00:11:09,000
எனவே நீங்கள் குறியீடு பல வரிசைகள் நூல்கள் யோசிக்க முடியும்

183
00:11:09,000 --> 00:11:11,000
அதே நேரத்தில் இயங்கும்.

184
00:11:11,000 --> 00:11:14,000
உண்மையில் உள்ள,, அது அநேகமாக, அதே இயங்கும் நேரத்தில் இல்லை உள்ளது

185
00:11:14,000 --> 00:11:17,000
ஆனால் அப்படி abstractly நாம் அந்த வழியில் அதை நினைக்க முடிகிறது.

186
00:11:17,000 --> 00:11:20,000
>> ஸ்க்ராட்ச் உள்ள, எடுத்துக்காட்டாக, நாம் பல மாய சிறுதெய்வ வடிவங்கள் இருந்தது.

187
00:11:20,000 --> 00:11:22,000
அதே நேரத்தில் வேறு குறியீடு இயக்கும்.

188
00:11:22,000 --> 00:11:26,000
மற்ற ஏதாவது சொல்கிறாய் என்று, அதே நேரத்தில் ஒரு நடைபயிற்சி முடியும்

189
00:11:26,000 --> 00:11:29,000
திரையில் வேறு பகுதியில்.

190
00:11:29,000 --> 00:11:34,000
நிகழ்வுகளை தர்க்கம் அவுட் பிரிப்பதில் உள்ள மற்றொரு வழியாக உள்ளன

191
00:11:34,000 --> 00:11:37,000
உங்கள் குறியீடு பற்றிய வெவ்வேறு தனிமங்களின் இடையே உள்ள,

192
00:11:37,000 --> 00:11:40,000
மற்றும் ஸ்க்ராட்ச் உள்ள நாம், பிராட்காஸ்ட் ஐ பயன்படுத்தி நிகழ்வுகளை உருவகப்படுத்த போலியான முடிந்தது

193
00:11:40,000 --> 00:11:43,000
நான் Receive போது மற்றும் என்று, நான் ஹியர் இல்லை போது,, உண்மையில் தான்

194
00:11:43,000 --> 00:11:47,000
ஆனால் அடிப்படையில், அது தகவல் டிரான்ஸ்மிட் செய்ய ஒரு வழி தான்

195
00:11:47,000 --> 00:11:49,000
ஒரு சிறு தெய்வம் இருந்து மற்றொரு செய்ய.

196
00:11:49,000 --> 00:11:52,000
உதாரணமாக, நீங்கள், விளையாட்டு மீது அனுப்ப வேண்டும்

197
00:11:52,000 --> 00:11:56,000
மற்றும் மற்றொரு சிறு தெய்வம் க்கும் மேற்பட்ட விளையாட்டு பெறுகிறது போது,

198
00:11:56,000 --> 00:11:58,000
இது ஒரு குறிப்பிட்ட வழியில் பதிலளிக்கும்.

199
00:11:58,000 --> 00:12:03,000
, அது நிரலாக்க க்கான புரிந்து கொள்ள ஒரு முக்கியமான மாதிரியை தான்.

200
00:12:03,000 --> 00:12:07,000
வெறும் அடிப்படை வீக் 0 க்கும் மேற்பட்ட செல்ல, என்ன, நாம் அவ்வளவு தூரம் க்கும் மேற்பட்ட போயிருக்கனும்,

201
00:12:07,000 --> 00:12:10,000
'ஸ் இந்த எளிய சி நிரல் பார் let.

202
00:12:10,000 --> 00:12:14,000
உரை இங்கே இருந்து சிறிய ஒரு சிறிய பிட் இருக்கலாம், ஆனால் நான், அது க்கும் மேற்பட்ட உண்மையில் விரைவான செல்கிறோம், நில்லுங்கள்,.

203
00:12:14,000 --> 00:12:20,000
நாம் மேலே, cs50.h மற்றும் stdio.h 2 தலைப்பு கோப்புகள் உட்பட.

204
00:12:20,000 --> 00:12:23,000
நாம், பின்னர் 100 இருக்க வேண்டும் ஒரு மாறிலி என்று அழைக்கப்படுகிறது வரம்பை வரையறுக்கும்போது நீங்கள்.

205
00:12:23,000 --> 00:12:26,000
நாம், பின்னர் எங்கள் முக்கிய செயல்பாடு அமல்படுத்தி நீங்கள்.

206
00:12:26,000 --> 00:12:29,000
நாம் இங்கே கட்டளை வரி வாதங்கள் பயன்படுத்த வேண்டாம் ல் இருந்து நாம் வெற்றிடத்தை நீங்கள் இடம்பெற செய்ய வேண்டும்

207
00:12:29,000 --> 00:12:32,000
முக்கிய க்கான வாதங்கள் போன்ற.

208
00:12:32,000 --> 00:12:38,000
நாம் முக்கிய மேலே உள்ள முழு எண்ணாக பார்க்க. பிரதியுபகாரமாக வகை தான் என்று, எனவே கீழே உள்ள 0 திரும்பி.

209
00:12:38,000 --> 00:12:41,000
மற்றும் நாம் முழு எண்ணாக கிடைக்கும் CS50 நூலகம் செயல்பாடு ஐ பயன்படுத்தி நீங்கள்

210
00:12:41,000 --> 00:12:45,000
உள்ளீடு க்கான பயனர் ask, மற்றும் நாம் இந்த மாறி x இல், அது சேமிக்க,

211
00:12:45,000 --> 00:12:51,000
, அதனால் நாம் மேலே உள்ள x அறிவிக்கலாம்,, மற்றும் நாம் x = GetInt உடன், அது துவக்க.

212
00:12:51,000 --> 00:12:53,000
>> நாம், பின்னர் பயனர் நம்மை நல்ல உள்ளீடு கொடுத்தது, இருந்தால், பார்க்க சரிபார்த்து.

213
00:12:53,000 --> 00:12:59,000
, அது ≥ அதிகபட்சம் LIMIT தான் இருந்தால், நாம் 1 பற்றிய ஒரு பிழை குறியீடு திரும்பி மற்றும் ஒரு பிழை செய்தியை அச்சிட வேண்டும்.

214
00:12:59,000 --> 00:13:02,000
மற்றும் இறுதியாக, பயனர் எங்களுக்கு கொடுத்தவற்றிற்கு இருந்தால், நல்ல உள்ளீடு

215
00:13:02,000 --> 00:13:08,000
நாம் எண் ஐ தற்பெருக்காக்கினால் விடை மற்றும் என்று இதன் விளைவாக, அவுட் அச்சிட போகிறோம்,.

216
00:13:08,000 --> 00:13:11,000
வெறும் உறுதிப்படுத்தி கொள்ள, என்று அந்த ஹிட் வீட்டில் அனைத்து

217
00:13:11,000 --> 00:13:17,000
நீங்கள் இங்கே குறியீடு வெவ்வேறு கணினி பாகங்கள் லேபிள்களுக்கு பார்க்க முடியும்.

218
00:13:17,000 --> 00:13:19,000
நான் மாறிலி, தலைப்பு கோப்புகள் குறிப்பிட்டுள்ளார்.

219
00:13:19,000 --> 00:13:21,000
ஓ, முழு எண்ணாக x. ஒரு உள்ளூர் மாறி தான் என்று நினைவில் கொள்ள உறுதிப்படுத்தி கொள்ளவும்,.

220
00:13:21,000 --> 00:13:24,000
என்று நாம் பேசுவோம் இது, உலக மாறி இருந்து முரண்படுகின்றது

221
00:13:24,000 --> 00:13:27,000
ஒரு சிறிய பிட் பின்னர் மறுஆய்வு அமர்வு உள்ள,

222
00:13:27,000 --> 00:13:30,000
மற்றும் நாம், printf நூலகம் செயல்பாடு என்று அழைக்கிறாய்

223
00:13:30,000 --> 00:13:34,000
நாம் stdio.h தலைப்பு கோப்பு சேர்க்கப்பட்டுள்ளது, இல்லை இருந்தது, அதனால் இருந்தால்,

224
00:13:34,000 --> 00:13:37,000
நாம் printf அழைக்க முடியாது என்று.

225
00:13:37,000 --> 00:13:42,000
மற்றும் நான், இங்கே ஆஃப் துண்டிக்கபட்டது என்று அம்புக்குறி% d க்கு சுட்டி காட்டியது உள்ளது நம்ப

226
00:13:42,000 --> 00:13:45,000
printf உள்ள ஒரு வடிவமைத்தலை சரம், இதில் ஆகும்.

227
00:13:45,000 --> 00:13:52,000
, அது ஒரு எண்,% d, போன்ற இந்த மாறி அவுட் அச்சிட மியூச்சுவல் நிதி.

228
00:13:52,000 --> 00:13:58,000
மற்றும் என்று வீக் 0 க்கான, அது ஆகும்.

229
00:13:58,000 --> 00:14:06,000
இப்போது லூகாஸ் தொடர்ந்து செய்ய போகிறாள்.

230
00:14:06,000 --> 00:14:08,000
ஏய்,, பசங்களா!. என் பெயர் லூகாஸ் ஆகும்.

231
00:14:08,000 --> 00:14:10,000
நான், வளாகம், மேத்தரால் மீது சிறந்த வீட்டை உள்ள ஒரு கல்லூரியின் இரண்டாம் ஆண்டு மாணவ இருக்கிறேன்

232
00:14:10,000 --> 00:14:14,000
மற்றும் நான் வீக் 1 மற்றும் 2.1 பற்றி ஒரு சிறிய பிட் பேச போகிறேன்,,,.

233
00:14:14,000 --> 00:14:16,000
[வீக் 1 மற்றும் 2.1!!] [லூகாஸ் Freitas]

234
00:14:16,000 --> 00:14:19,000
நாம் ஸ்க்ராட்ச் இருந்து சி செய்ய உங்கள் குறியீடு மொழிபெயர்ப்பது தொடங்கியது, போது Lexi, என்று கூறி செய்யப்பட்டது போன்ற

235
00:14:19,000 --> 00:14:23,000
நாம் அறிகிறோம் விஷயங்களை ஒன்று நீங்கள் தான் முடியும் என்று

236
00:14:23,000 --> 00:14:26,000
உங்கள் குறியீடு எழுத மற்றும் இனி ஒரு பச்சை கொடி ஐ பயன்படுத்தி, அது ரன் அவுட்.

237
00:14:26,000 --> 00:14:30,000
, உண்மையில், நீங்கள் உங்கள் சி நிரல் செய்ய சில படிநிலைகளை பயன்படுத்த வேண்டும்

238
00:14:30,000 --> 00:14:33,000
செயல்படும் கோப்பை மாறியது.

239
00:14:33,000 --> 00:14:36,000
அடிப்படையில் என்ன ஒரு நிரல் எழுதும் போது என்ன ஆகும் என்று

240
00:14:36,000 --> 00:14:40,000
நீங்கள், ஒரு மொழி புரிந்து கொள்ள முடியும் என்று ஒரு மொழி உங்கள் கருத்தை மொழிபெயர்க்க

241
00:14:40,000 --> 00:14:44,000
நீங்கள் சி உள்ள ஒரு நிரல் எழுதுவதில் நீங்கள், அதனால் போது

242
00:14:44,000 --> 00:14:47,000
என்ன நீங்கள் செய்துவருகிறோம், உண்மையில் உங்கள் தொகுப்பி புரிந்துகொள்ள போகிறார்கள் என்று ஏதாவது எழுதுவதில் உள்ளது,

243
00:14:47,000 --> 00:14:50,000
மற்றும், பின்னர் தொகுப்பி என்று குறியீடு மொழிபெயர்க்க போகிறாள் என்று

244
00:14:50,000 --> 00:14:53,000
, உங்கள் கணினியை புரிந்து கொள்ள என்று ஏதாவது பிரிக்கப்படுகின்றன.

245
00:14:53,000 --> 00:14:55,000
>> மற்றும் விஷயம்,,, உங்கள் கணினியை, உண்மையில் மிகவும் ஊமை உள்ளது.

246
00:14:55,000 --> 00:14:57,000
உங்கள் கணினியில் மட்டுமே, 0 க்கள் மற்றும் 1 வி புரிந்து கொள்ள முடியும்

247
00:14:57,000 --> 00:15:01,000
எனவே உண்மையில் முதல் கணினிகள் மக்கள் பொதுவாக நிரல்படுத்தலாம்

248
00:15:01,000 --> 00:15:04,000
இனி 0 க்கள் மற்றும் 1 வி, ஆனால் பயன்படுத்தி, கடவுளுக்கு நன்றி.

249
00:15:04,000 --> 00:15:07,000
நாம் 0 வி மற்றும் 1 வி க்கான தொடர்ச்சிகள் மட்டும் பாக்கியிருந்தன, நினைவில்கொள்ள இல்லை

250
00:15:07,000 --> 00:15:10,000
லுப்பில் க்கான அல்லது ஒரு, அதே நேரத்தில் லுப்பில் மற்றும், அதனால் மீது க்கான ஒரு க்கான.

251
00:15:10,000 --> 00:15:13,000
நாம் ஒரு மொழி உண்டு, அதனால் தான்.

252
00:15:13,000 --> 00:15:17,000
என்ன ஒரு தொகுப்பி செய்கிறது,, அது அடிப்படையில் சி குறியீடு மொழிகளிலிருந்து மொழியாக்கம் செய்ய ஆகும்

253
00:15:17,000 --> 00:15:21,000
எங்கள் வழக்கு உள்ள,, உங்கள் கணினியை புரிந்து கொள்ள என்று ஒரு மொழி செய்ய,

254
00:15:21,000 --> 00:15:25,000
, இதில் பொருள் குறியீடு, மற்றும் நாம் ஐ பயன்படுத்தி உள்ளோம் என்று நான் தொகுப்பி ஆகும்

255
00:15:25,000 --> 00:15:30,000
கணகண வென்ற சப்தம் என்று அழைக்கப்படுகிறது,,, அதனால் இந்த, உண்மையில் கணகண வென்ற சப்தம் க்கான சின்னமாக உள்ளது.

256
00:15:30,000 --> 00:15:33,000
நீங்கள் உங்கள் நிரல் வேண்டும் போது, நீங்கள் 2 விஷயங்களை செய்தாக வேண்டும்.

257
00:15:33,000 --> 00:15:37,000
முதல், நீங்கள் உங்கள் நிரல் தொகுக்க வேண்டும், பின்னர் உங்கள் நிரலை இயக்க போகிறீர்கள்.

258
00:15:37,000 --> 00:15:41,000
நீங்கள் அவ்வாறு செய்ய விருப்பங்களை நிறைய உங்கள் திட்டம் தொகுக்க.

259
00:15:41,000 --> 00:15:44,000
முதல் ஒரு கணகண வென்ற சப்தம் program.c செய்ய உள்ளது

260
00:15:44,000 --> 00:15:47,000
இதில் நிரல் உங்கள் திட்டத்தின் பெயர்.

261
00:15:47,000 --> 00:15:51,000
இந்த வழக்கில் அவர்கள் தான் சொல்கிறார்கள் பார்க்க முடியும் "ஏய், என் திட்டத்தை தொகுக்கலாம்."

262
00:15:51,000 --> 00:15:56,000
நீங்கள் அல்லது ஏதாவது "நான் என் திட்டத்தை இந்த பெயர் வேண்டும்" என்று நாங்கள் சொல்லவில்லை.

263
00:15:56,000 --> 00:15:58,000
>> இரண்டாவது விருப்பத்தை உங்கள் திட்டத்தை ஒரு பெயர் கொடுத்து.

264
00:15:58,000 --> 00:16:02,000
நீங்கள் கணகண வென்ற சப்தம்-o நீங்கள் விரும்பும் பெயரை சொல்ல முடியாது

265
00:16:02,000 --> 00:16:06,000
இயக்கக்கூடிய கோப்பை மற்றும் பிறகு program.c என்ற வேண்டும்.

266
00:16:06,000 --> 00:16:11,000
மற்றும் நீங்கள் உருவாக்க வேண்டும், எப்படி முதல் 2 இடங்களில் பார்க்க முடியும்

267
00:16:11,000 --> 00:16:15,000
நான். கேட்ச் வைத்து, மற்றும் மூன்றாவது ஒரு நான் மட்டுமே திட்டங்கள் இல்லை?

268
00:16:15,000 --> 00:16:18,000
சரி, நீங்கள் உண்மையில் போட கூடாது. கேட்ச் நீங்கள் பயன்படுத்த போது.

269
00:16:18,000 --> 00:16:22,000
இல்லையெனில் தொகுப்பி உண்மையில் நீங்கள் கத்துகிறாய் போகிறது.

270
00:16:22,000 --> 00:16:24,000
உங்களுக்கு நினைவிருக்கிறதா மேலும், நான், எனக்கு தெரியாது

271
00:16:24,000 --> 00:16:29,000
ஆனால் நாம் பயன்படுத்த-lcs50 அல்லது LM முறை நிறைய.

272
00:16:29,000 --> 00:16:31,000
அந்த இணைப்பு அழைக்கப்படுகிறது.

273
00:16:31,000 --> 00:16:35,000
அது, நீங்கள் அங்கே அந்த நூலகங்கள் பயன்படுத்த என்று தொகுப்பி சொல்கிறது

274
00:16:35,000 --> 00:16:39,000
நீங்கள் cs50.h பயன்படுத்த வேண்டும் என்று நீங்கள் உண்மையிலேயே தட்டச்சு செய்ய வேண்டும்

275
00:16:39,000 --> 00:16:43,000
கணகண வென்ற சப்தம் program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
நீங்கள் செய்யவில்லை என்றால், ஒடுக்கி தெரிய போவதில்லை

277
00:16:45,000 --> 00:16:50,000
நீங்கள் cs50.h. அந்த செயல்பாடுகளை பயன்படுத்தி என்று

278
00:16:50,000 --> 00:16:52,000
நீங்கள் 2 விருப்பங்கள் உங்கள் நிரலை இயக்க வேண்டும் போது.

279
00:16:52,000 --> 00:16:57,000
நீங்கள் கணகண வென்ற சப்தம் program.c செய்தால் நீங்கள் உங்கள் நிரல் பெயர் சொல்லவில்லை.

280
00:16:57,000 --> 00:17:01,000
நீங்கள். / A.out பயன்படுத்தி அதை இயக்க வேண்டும்.

281
00:17:01,000 --> 00:17:06,000
A.out நீங்கள் ஒரு பெயரை என்றால் கணகண வென்ற சப்தம் உங்கள் திட்டத்தை வழங்கும் ஒரு நிலையான பெயர்.

282
00:17:06,000 --> 00:17:11,000
உங்கள் திட்டத்தை ஒரு பெயர் கொடுத்து, இல்லையெனில் நீங்கள். / நிரல் செய்ய போகிறோம்,

283
00:17:11,000 --> 00:17:15,000
நீங்கள் நிரல் பெயர் வைக்க செய்தால் மேலும் ஒரு நிரலை போகிறது என்று

284
00:17:15,000 --> 00:17:23,000
ஏற்கனவே கேட்ச் கோப்பு அதே பெயர் திட்டமிடப்பட்டது போகிறது.

285
00:17:23,000 --> 00:17:26,000
நாம் தரவு வகைகள் மற்றும் தரவு பேசினார்.

286
00:17:26,000 --> 00:17:31,000
>> அடிப்படையில் தரவு வகைகள் அவர்கள் பயன்படுத்தும் சிறிய பெட்டிகள் அதே விஷயம் இல்லை

287
00:17:31,000 --> 00:17:35,000
மதிப்புகள் சேமிக்க, அதனால் தரவு வகைகள் மட்டும் Pokémons போன்ற உண்மையில்.

288
00:17:35,000 --> 00:17:39,000
அவர்கள் அனைத்து அளவுகள் மற்றும் வகைகள் வந்து.

289
00:17:39,000 --> 00:17:43,000
அந்த ஒப்புமை அர்த்தமுள்ளதாக என்றால் எனக்கு தெரியாது.

290
00:17:43,000 --> 00:17:46,000
தரவு அளவு உண்மையில் இயந்திரம் கட்டமைப்பு பொறுத்தது.

291
00:17:46,000 --> 00:17:49,000
நான் இங்கே காட்ட போகிறேன் என்று அனைத்து தரவு அளவுகள்

292
00:17:49,000 --> 00:17:53,000
நமது பயன்பாட்டிற்கான விஷயத்தில் இது ஒரு 32 பிட் கணினியில், உண்மையாக இருக்கும்

293
00:17:53,000 --> 00:17:56,000
ஆனால் நீங்கள் உண்மையில் உங்கள் மேக் அல்லது விண்டோஸ் மேலும் குறியீட்டு இருந்தால்

294
00:17:56,000 --> 00:17:59,000
ஒருவேளை நீங்கள், ஒரு 64 பிட் கணினியில் போகிறது

295
00:17:59,000 --> 00:18:03,000
நான் செல்கிறேன் என்று தரவு அளவுகள் இங்கே காட்ட நினைவில்

296
00:18:03,000 --> 00:18:06,000
32 பிட் கணினியில் இருக்கும்.

297
00:18:06,000 --> 00:18:08,000
நாங்கள் பார்த்த முதல் ஒரு, ஒரு முழு எண்ணாக இருந்தது

298
00:18:08,000 --> 00:18:10,000
இது மிகவும் நேர்மையானவன்.

299
00:18:10,000 --> 00:18:13,000
நீங்கள் ஒரு முழு எண் சேமிக்க எண்ணாக பயன்படுத்த.

300
00:18:13,000 --> 00:18:16,000
நாங்கள் தன்மை, கரி பார்த்தேன்.

301
00:18:16,000 --> 00:18:20,000
நீங்கள் ஒரு கடிதம் அல்லது ஒரு சிறிய சின்னம் பயன்படுத்த விரும்பினால் நீங்கள் ஒரு எரிப்பதை பயன்படுத்த போகிறோம்.

302
00:18:20,000 --> 00:18:26,000
ஒரு எரிப்பதை Lexi கூறினார் போன்ற 8 பிட்கள், அதாவது 1 பைட், உள்ளது.

303
00:18:26,000 --> 00:18:31,000
அடிப்படையில் நாம் 256 என்று ஒரு ஆஸ்கி அட்டவணை வேண்டும்

304
00:18:31,000 --> 00:18:34,000
0 க்கள் மற்றும் 1 வி சாத்தியமான சேர்க்கைகள்,

305
00:18:34,000 --> 00:18:37,000
பின்னர் நீங்கள் ஒரு எரிப்பதை தட்டச்சு போது அதை மொழிபெயர்க்க நடக்கிறது

306
00:18:37,000 --> 00:18:44,000
பாத்திரம் உள்ளீடுகள் நீங்கள் Lexi போல், ஆஸ்கி அட்டவணையில் வேண்டும் என்று பல என்று.

307
00:18:44,000 --> 00:18:48,000
நாம் தசம எண்கள் சேமிக்க பயன்படுத்தும் மிதவை, இல்லை.

308
00:18:48,000 --> 00:18:53,000
நீங்கள் 3,14 தேர்வு செய்ய விரும்பினால், எடுத்துக்காட்டாக, நீங்கள் ஒரு மிதவை பயன்படுத்த போகிறோம்

309
00:18:53,000 --> 00:18:55,000
அல்லது இன்னும் துல்லியமாக என்று ஒரு இரட்டை.

310
00:18:55,000 --> 00:18:57,000
ஒரு மிதவை 4 பைட்டுகள் உள்ளது.

311
00:18:57,000 --> 00:19:01,000
ஒரு இரட்டை 8 பைட்டுகள், அதனால் மட்டுமே வேறுபாடு துல்லியமாக உள்ளது.

312
00:19:01,000 --> 00:19:04,000
நாங்கள் முழு எண்கள் பயன்படுத்தப்படும் என்று ஒரு நீண்ட வேண்டும்

313
00:19:04,000 --> 00:19:09,000
நீங்கள், ஒரு முழு எண்ணாக மற்றும் நீண்ட அதே அளவு இருக்கும் ஒரு 32 பிட் கணினியில் பார்க்கலாம்

314
00:19:09,000 --> 00:19:13,000
அது உண்மையில் ஒரு 32 பிட் கணினியில் நீண்ட பயன்படுத்த பயன் இல்லை.

315
00:19:13,000 --> 00:19:17,000
>> நீங்கள் ஒரு மேக் மற்றும் 64 பிட் கணினியில் பயன்படுத்தி நீங்கள் ஆனால், உண்மையில் ஒரு நீண்ட, அளவு 8 உள்ளது

316
00:19:17,000 --> 00:19:19,000
அது உண்மையில் கட்டமைப்பு சார்ந்துள்ளது.

317
00:19:19,000 --> 00:19:22,000
32 பிட் கணினியில் அது உண்மையில் ஒரு நீண்ட பயன்படுத்த பயன் இல்லை.

318
00:19:22,000 --> 00:19:25,000
பின்னர் ஒரு நீண்ட நீண்ட, மறுபுறம், 8 பைட்டுகள் உள்ளது

319
00:19:25,000 --> 00:19:30,000
நீங்கள் நீண்ட முழு வேண்டும் என்றால் அது மிகவும் நல்லது.

320
00:19:30,000 --> 00:19:34,000
இறுதியாக, நாம், உண்மையில் ஒரு எரிப்பதை * இது, சரம் இல்லை

321
00:19:34,000 --> 00:19:37,000
இது ஒரு எரிப்பதை ஒரு சுட்டிக்காட்டி இருக்கிறது.

322
00:19:37,000 --> 00:19:40,000
இது சரம் அளவு இருக்கும் என்று நினைக்கிறேன் மிக எளிது

323
00:19:40,000 --> 00:19:42,000
நீ அங்கு இல்லை என்று கதாபாத்திரங்கள் எண்ணிக்கை,

324
00:19:42,000 --> 00:19:45,000
ஆனால் உண்மையில் எரிப்பதை * தன்னை

325
00:19:45,000 --> 00:19:49,000
4 பைட்டுகள் இது ஒரு கரி, ஒரு சுட்டிக்காட்டி அளவு உள்ளது.

326
00:19:49,000 --> 00:19:52,000
ஒரு எரிப்பதை * அளவு 4 பைட்டுகள் ஆகும்.

327
00:19:52,000 --> 00:19:56,000
நீங்கள் ஒரு சிறிய வார்த்தை அல்லது ஒரு கடிதம் அல்லது ஏதாவது இருந்தால் பரவாயில்லை.

328
00:19:56,000 --> 00:19:58,000
இது 4 பைட்டுகள் இருக்க போகிறது.

329
00:19:58,000 --> 00:20:01,000
நாங்கள், நடிப்பு பற்றி கொஞ்சம் தெரிந்து

330
00:20:01,000 --> 00:20:04,000
நீங்கள் இருந்தால் நீங்கள் பார்க்க முடியும் என, எடுத்துக்காட்டாக, ஒரு திட்டம் கூறுகிறது

331
00:20:04,000 --> 00:20:08,000
int x = 3 மற்றும் பிறகு printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
நீங்கள் அதை திரையில் அச்சிட என்ன நடக்கிறது என்று தெரியுமா?

333
00:20:12,000 --> 00:20:14,000
>> யாரோ? >> [மாணவர்கள்] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, yeah.

335
00:20:16,000 --> 00:20:20,000
நீங்கள் 3/2 செய்யும் போது அது, 1.5 பெற நடக்கிறது

336
00:20:20,000 --> 00:20:24,000
நாம் ஒரு முழு பயன்படுத்தும் இருந்து ஆனால் அது, தசம பாகம் புறக்கணிக்க நடக்கிறது

337
00:20:24,000 --> 00:20:26,000
நீங்கள் 1 போகிறது.

338
00:20:26,000 --> 00:20:29,000
நீங்கள், உதாரணமாக, நீங்கள் என்ன செய்ய முடியும் நடக்க வேண்டும் என்றால்

339
00:20:29,000 --> 00:20:33,000
ஒரு மிதவை அறிவிக்க உள்ளது y = x.

340
00:20:33,000 --> 00:20:40,000
பின்னர் 3 பயன்படுத்தப்படும் என்று x இப்போது y உள்ள 3,000 ஆக போகிறது.

341
00:20:40,000 --> 00:20:44,000
பின்னர் நீங்கள் y / 2 அச்சிட முடியாது.

342
00:20:44,000 --> 00:20:50,000
உண்மையில், நான் ஒரு 2 வேண்டும். அங்கு.

343
00:20:50,000 --> 00:20:55,000
இது, 3.00/2.00 செய்ய நடக்கிறது

344
00:20:55,000 --> 00:20:58,000
நீங்கள் 1.5 போகிறோம்.

345
00:20:58,000 --> 00:21:06,000
நாம் தான் தசம பகுதி 2 தசம அலகுகள் கேட்க இந்த .2 f வேண்டும்.

346
00:21:06,000 --> 00:21:12,000
நீங்கள் .3 f இருந்தால் அது உண்மையில் 1,500 வேண்டும் நடக்கிறது.

347
00:21:12,000 --> 00:21:16,000
அது இருந்தால் 2 இது 1.50 ஆக போகிறது.

348
00:21:16,000 --> 00:21:18,000
நாங்கள் இங்கே இந்த வழக்கு உள்ளது.

349
00:21:18,000 --> 00:21:22,000
நீங்கள் பங்குகளாக செய்தால் x = 3,14 மற்றும் நீங்கள் printf x

350
00:21:22,000 --> 00:21:24,000
நீங்கள் 3,14 போகிறோம்.

351
00:21:24,000 --> 00:21:29,000
நீங்கள் செய்தால் x x இன் = int,

352
00:21:29,000 --> 00:21:34,000
ஒரு முழு எண்ணாக போன்ற x சிகிச்சை பொருள் மற்றும் நீங்கள் இப்போது x அச்சிட இது

353
00:21:34,000 --> 00:21:36,000
நீங்கள் 3.00 போகிறது.

354
00:21:36,000 --> 00:21:38,000
அந்த உணர்வு ஏற்படுத்தும்?

355
00:21:38,000 --> 00:21:41,000
நீங்கள் முதல் முழு எண்ணாக x சிகிச்சை தான் காரணம், அதனால், தசம பாகம் அசட்டை

356
00:21:41,000 --> 00:21:45,000
பின்னர் நீங்கள் x அச்சிடுகிறது.

357
00:21:45,000 --> 00:21:47,000
இறுதியாக, நீங்கள், இதை செய்ய முடியும்

358
00:21:47,000 --> 00:21:52,000
int x = 65, மற்றும் நீங்கள் ஒரு கரி கேட்ச் = x அறிவிக்க,

359
00:21:52,000 --> 00:21:56,000
நீங்கள் கேட்ச் அச்சிட என்றால், பிறகு நீங்கள் உண்மையில் போகிறோம்

360
00:21:56,000 --> 00:21:59,000
ஒரு, நீங்கள் இங்கே இவ்வளவு அடிப்படையில் என்ன செய்கிறாய்

361
00:21:59,000 --> 00:22:02,000
, கதாபாத்திரமாக முழு மொழிபெயர்ப்பது

362
00:22:02,000 --> 00:22:05,000
போல் ஆஸ்கி அட்டவணை இல்லை.

363
00:22:05,000 --> 00:22:08,000
நாங்கள் கணித ஆபரேட்டர்கள் பற்றி பேசினார்.

364
00:22:08,000 --> 00:22:14,000
அவர்கள் மிகவும் அழகாக நேரடியான, அதனால் + -, *, /,

365
00:22:14,000 --> 00:22:20,000
மேலும் நாங்கள் 2 எண்கள் ஒரு பிரிவு எஞ்சிய இது மோட், பேசினார்.

366
00:22:20,000 --> 00:22:23,000
நீங்கள் உதாரணமாக 10% 3, இருந்தால்

367
00:22:23,000 --> 00:22:27,000
இது 3 10 பிரித்து பொருள், மற்றும் எஞ்சிய என்ன?

368
00:22:27,000 --> 00:22:30,000
இது 1 ஆக போகிறது, அது திட்டங்கள் நிறைய உண்மையாக மிகவும் பயனுள்ளதாக இருக்கும்.

369
00:22:30,000 --> 00:22:38,000
வைஜெனேர் மற்றும் சீசர் நான் உங்களுக்கு அனைத்து மோட் பயன்படுத்தப்படும் என்று அழகாக தெரியும்.

370
00:22:38,000 --> 00:22:43,000
* மற்றும் / இணைந்த போது கணித ஆபரேட்டர்கள் பற்றி, மிகவும் கவனமாக இருக்க வேண்டும்.

371
00:22:43,000 --> 00:22:48,000
>> நீங்கள் செய்தால் உதாரணமாக, (3/2) * 2 என்ன செய்ய போகிறீர்கள்?

372
00:22:48,000 --> 00:22:50,000
[மாணவர்கள்] 2.

373
00:22:50,000 --> 00:22:54,000
சரி, 2, 3/2 ஏனெனில் 1.5 ஆக போகிறது,

374
00:22:54,000 --> 00:22:57,000
ஆனால் நீங்கள் 2 முழு இடையே நடவடிக்கைகளை செய்கிறீர்கள் இருந்து

375
00:22:57,000 --> 00:22:59,000
நீங்கள் உண்மையில் நான், 1 கருத்தில் கொள்ள போகிறோம்

376
00:22:59,000 --> 00:23:03,000
பின்னர் 1 * 2 2 போகிறது, அதனால் மிக, மிக கவனமாக இருக்க வேண்டும்

377
00:23:03,000 --> 00:23:07,000
முழு எண்களின் கூட்டல் செய்யும்போது, ஏனெனில்

378
00:23:07,000 --> 00:23:12,000
நீங்கள் அந்த வழக்கில், அந்த 2 = 3 வந்துவிடும்.

379
00:23:12,000 --> 00:23:14,000
மேலும் முன்னுரிமை பற்றி மிகவும் கவனமாக இருக்க வேண்டும்.

380
00:23:14,000 --> 00:23:21,000
நீங்கள் வழக்கமாக நீங்கள் செய்கிறீர்கள் என்று உறுதியாக இருக்க வேண்டும் அடைப்புக்குறிக்குள் பயன்படுத்த வேண்டும்.

381
00:23:21,000 --> 00:23:27,000
சில பயனுள்ள குறுக்குவழிகளை, நிச்சயமாக, ஒரு நான் + அல்லது நான் + = 1

382
00:23:27,000 --> 00:23:30,000
அல்லது பயன்படுத்தி + =.

383
00:23:30,000 --> 00:23:34,000
என்று நான் = நான் + 1 செய்து அதே விஷயம்.

384
00:23:34,000 --> 00:23:39,000
நீங்கள் நான் என்ன செய்ய முடியும் - அல்லது நான் - = 1,

385
00:23:39,000 --> 00:23:42,000
இது, நான் = நான் -1 அதே விஷயம்

386
00:23:42,000 --> 00:23:46,000
ஒன்று நீங்கள் குறைந்தது, சுழல்கள் உள்ள நிறைய பயன்படுத்த.

387
00:23:46,000 --> 00:23:52,000
மேலும், * நீ * = நீங்கள் செய்தால், உதாரணமாக பயன்படுத்தினால்,

388
00:23:52,000 --> 00:23:57,000
நான் * = 2 நான் = நான் * 2 கூறி அதே விஷயம்,

389
00:23:57,000 --> 00:23:59,000
மற்றும் பிரிவு ஒரே விஷயம்.

390
00:23:59,000 --> 00:24:08,000
நீங்கள் நான் / = 2 செய்தால் அதை நான் = நான் / 2 அதே விஷயம்.

391
00:24:08,000 --> 00:24:10,000
>> இப்போது செயல்பாடுகளை பற்றி.

392
00:24:10,000 --> 00:24:13,000
நீங்கள் செயல்பாடுகளை குறியீடு காப்பாற்ற ஒரு நல்ல உத்தி என்பதை கற்று

393
00:24:13,000 --> 00:24:16,000
நீங்கள் நிகழ்ச்சிகளை நீங்கள் போது, நீ அதே பணியை செய்ய விரும்பினால்

394
00:24:16,000 --> 00:24:20,000
குறியீடு மீண்டும் மீண்டும், ஒருவேளை நீங்கள் ஒரு செயல்பாட்டை பயன்படுத்த வேண்டும்

395
00:24:20,000 --> 00:24:25,000
இப்போது நீங்கள் மீண்டும் மேல் குறியீடு நகலெடுத்து ஒட்டவும் இல்லை.

396
00:24:25,000 --> 00:24:28,000
உண்மையில், முக்கிய செயல்பாடாக இருக்கிறது, நான் உங்களுக்கு ஒரு சார்பு வடிவம் காட்ட போது

397
00:24:28,000 --> 00:24:32,000
நீங்கள் அழகாக தெளிவாக இருக்கிறது என்று பார்க்க போகிறோம்.

398
00:24:32,000 --> 00:24:35,000
நாங்கள், சில நூலகங்களில் இருந்து செயல்பாடுகளை பயன்படுத்துவது

399
00:24:35,000 --> 00:24:39,000
எடுத்துக்காட்டாக, printf, CS50 நூலகம் இருந்து இது GetIn,,

400
00:24:39,000 --> 00:24:43,000
மற்றும் toupper போன்ற மற்ற செயல்பாடுகள்.

401
00:24:43,000 --> 00:24:46,000
அந்த பணிகள் அனைத்தும் உண்மையில், மற்ற நூலகங்கள் நடைமுறைப்படுத்தப்படுகின்றன

402
00:24:46,000 --> 00:24:49,000
நீங்கள் உங்கள் திட்டத்தில் ஆரம்பத்தில் அந்த தாம்பு கோப்புகளை வைத்து போது

403
00:24:49,000 --> 00:24:53,000
நீங்கள் என்னை அந்த செயல்பாடுகளுக்கு குறியீடு கொடுங்கள் முடியும் சொல்கிறாய்

404
00:24:53,000 --> 00:24:57,000
அதனால் நான் அவற்றை செயல்படுத்த இல்லை?

405
00:24:57,000 --> 00:25:00,000
மற்றும் நீங்கள் நிரலாக்க தொடங்கும் போது, உங்கள் சொந்த செயல்பாடுகளை எழுதலாம்

406
00:25:00,000 --> 00:25:04,000
நீங்கள் நூலகங்கள் உங்களுக்கு தேவையான அனைத்து செயல்பாடுகளும் இல்லை என்று.

407
00:25:04,000 --> 00:25:10,000
கடந்த pset, உதாரணமாக, நாம், போராட்டம் வரைந்து, மற்றும் தேடல் எழுதியது

408
00:25:10,000 --> 00:25:13,000
அது செயல்பாடுகளை எழுத முடியும் மிக, மிக முக்கியம்

409
00:25:13,000 --> 00:25:17,000
அவர்கள் பயனுள்ளதாக இருக்கும், மற்றும் நாம் நிரலாக்க அனைத்து நேரம் பயன்படுத்தினால், ஏனெனில்,

410
00:25:17,000 --> 00:25:19,000
அது குறியீடு நிறைய சேமிக்கிறது.

411
00:25:19,000 --> 00:25:21,000
ஒரு சார்பு வடிவம் இந்த ஒன்றாகும்.

412
00:25:21,000 --> 00:25:24,000
நாம் தொடக்கத்தில் மீண்டும் வகை உண்டு. மீண்டும் வகை என்ன?

413
00:25:24,000 --> 00:25:27,000
இது உங்கள் செயல்பாடு திரும்ப போகும் போது மட்டும் தான்.

414
00:25:27,000 --> 00:25:29,000
நீங்கள் காரணியாலான உதாரணமாக ஒரு செயல்பாடு,,, இருந்தால்

415
00:25:29,000 --> 00:25:31,000
என்று, ஒரு முழு ஒரு காரணியாலான கணக்கிட நடக்கிறது

416
00:25:31,000 --> 00:25:34,000
ஒருவேளை இது ஒரு முழு எண் திரும்ப நடக்கிறது.

417
00:25:34,000 --> 00:25:37,000
பின்னர் மீண்டும் வகை எண்ணாக இருக்க போகிறது.

418
00:25:37,000 --> 00:25:41,000
Printf உண்மையில் மீண்டும் வகை வெற்றிடத்தை உள்ளது

419
00:25:41,000 --> 00:25:43,000
நீங்கள் எதையும் திரும்பி இருப்பதால்.

420
00:25:43,000 --> 00:25:45,000
நீங்கள் திரையில் விஷயங்களை அச்சிடுதல்

421
00:25:45,000 --> 00:25:48,000
பின்னர் விழாவில் விட்டுவிடுதல்.

422
00:25:48,000 --> 00:25:51,000
பிறகு நீங்கள் தேர்வு செய்யலாம் என்று செயல்பாடு பெயர் உண்டு.

423
00:25:51,000 --> 00:25:55,000
Xyz போன்ற ஒரு பெயரை தேர்வு இல்லை போல, ஒரு சிறிய நியாயமாக இருக்க வேண்டும்

424
00:25:55,000 --> 00:25:58,000
அல்லது x2f போல்.

425
00:25:58,000 --> 00:26:02,000
அர்த்தமுள்ளதாக என்று ஒரு பெயர் புனைய முயற்சி.

426
00:26:02,000 --> 00:26:04,000
>> உதாரணமாக, அதை காரணியாலான என்றால், காரணியாலான என்று.

427
00:26:04,000 --> 00:26:08,000
இது ஏதோ வரைய என்று ஒரு செயல்பாடு இருந்தால், அதை வரைந்து பெயரை.

428
00:26:08,000 --> 00:26:11,000
பின்னர் நாங்கள் வாதங்களை அழைக்கப்படுகின்றன அளவுருக்கள்,, இல்லை

429
00:26:11,000 --> 00:26:14,000
உங்கள் செயல்பாடு தேவை என்று வளங்களை போன்ற இவை

430
00:26:14,000 --> 00:26:17,000
உங்கள் குறியீடு இருந்து அதன் பணியை செய்ய.

431
00:26:17,000 --> 00:26:20,000
நீங்கள் பல காரணியாலான கணக்கிட விரும்பினால்

432
00:26:20,000 --> 00:26:23,000
ஒருவேளை நீங்கள் ஒரு காரணியாலான கணக்கிட பல வேண்டும்.

433
00:26:23,000 --> 00:26:27,000
நீங்கள் போகிறது என்று வாதங்கள் ஒரு எண் ஆகும்.

434
00:26:27,000 --> 00:26:31,000
பின்னர் அது ஏதாவது மற்றும் இறுதியில் மதிப்பு திரும்ப நடக்கிறது

435
00:26:31,000 --> 00:26:35,000
அது ஒரு வெற்றிடத்தை விழா வரை.

436
00:26:35,000 --> 00:26:37,000
இது ஒரு உதாரணம் பார்க்கலாம்.

437
00:26:37,000 --> 00:26:40,000
நான், முழுஎண்களின் ஒரு வரிசையில் எண்கள் மொத்த அளவை வைத்து ஒரு செயல்பாடு எழுத விரும்பினால்

438
00:26:40,000 --> 00:26:43,000
அனைத்து முதல், திரும்பி வகை எண்ணாக இருக்கும்

439
00:26:43,000 --> 00:26:46,000
நான் முழு ஒரு வரிசைக்கு காரணம்.

440
00:26:46,000 --> 00:26:51,000
பின்னர் நான், sumArray போன்ற செயல்பாடு பெயரை போகிறேன்

441
00:26:51,000 --> 00:26:54,000
பின்னர், முழு எண்ணாக nums வேண்டும், வரிசை தன்னை அழைத்து நடக்கிறது

442
00:26:54,000 --> 00:26:58,000
பின்னர் நான் தொகையிடும் வேண்டும் எத்தனை எண்கள் தெரியும் அதனால் வரிசை நீளம்.

443
00:26:58,000 --> 00:27:02,000
நான் 0 உதாரணத்திற்கு ஒரு மாறி என்று தொகை,,, துவக்க வேண்டும்

444
00:27:02,000 --> 00:27:08,000
நான் வரிசையில் ஒரு உறுப்பு பார்க்க ஒவ்வொரு முறையும் நான் கூட்டுத்தொகையாக சேர்க்க வேண்டும், அதனால் நான் வளைய ஒரு செய்தார்.

445
00:27:08,000 --> 00:27:15,000
Lexi சொன்னது போல, நீங்கள் எண்ணாக நான் = 0, நான் <நீளம் மற்றும் +.

446
00:27:15,000 --> 00:27:20,000
மற்றும் வரிசை ஒவ்வொரு உறுப்பு நான் கூட்டுத்தொகையாக + = nums [நான்] செய்தது,

447
00:27:20,000 --> 00:27:24,000
பின்னர் நான் தொகை திருப்பி, அது மிகவும் எளிது, மற்றும் அது குறியீடு நிறைய சேமிக்கிறது

448
00:27:24,000 --> 00:27:28,000
இந்த விழாவில் நிறைய தடவை பயன்படுத்தி நீங்கள்.

449
00:27:28,000 --> 00:27:32,000
நாம் நிலைமைகளை பார்த்துக்கொண்டோம்.

450
00:27:32,000 --> 00:27:38,000
நாம் வேறு, அது வேண்டும், மற்றும் வேறு என்றால்.

451
00:27:38,000 --> 00:27:42,000
அந்த வித்தியாசம் என்ன என்று பார்ப்போம்.

452
00:27:42,000 --> 00:27:45,000
இந்த 2 குறியீடுகள் பாருங்கள். அவர்களுக்கு இடையே என்ன வேறுபாடு உள்ளது?

453
00:27:45,000 --> 00:27:49,000
முதல் ஒரு அடிப்படையில் குறியீடுகள் நான் உங்களுக்கு சொல்ல விரும்புகிறேன்

454
00:27:49,000 --> 00:27:51,000
, அல்லது 0 - பல + என்றால்.

455
00:27:51,000 --> 00:27:55,000
முதல் ஒரு அதை> 0 என்று அது சாதகமான விஷயம் என்கிறார்.

456
00:27:55,000 --> 00:28:00,000
அது 0 = இருந்தால் அது 0, அது <0 இருந்தால் அது எதிர்மறையான தான்.

457
00:28:00,000 --> 00:28:04,000
>> வேறு, வேறு, நீங்கள் வேறு ஒரு செய்கிறார்.

458
00:28:04,000 --> 00:28:07,000
இரண்டு இடையே உள்ள வேறுபாடு இந்த ஒரு உண்மையில் என்ன என்று

459
00:28:07,000 --> 00:28:13,000
சரி என்றால்> 0, <0 அல்லது = 0 மூன்று முறை,

460
00:28:13,000 --> 00:28:17,000
நீங்கள் பல 2 இருக்கிறது என்றால், எடுத்துக்காட்டாக, அதை இங்கே வந்து சொல்ல நடக்கிறது

461
00:28:17,000 --> 00:28:21,000
அது சரி என்று நடக்கிறது (x> 0) என்றால், மற்றும், அதனால் நான் நேர்மறை அச்சிட.

462
00:28:21,000 --> 00:28:25,000
ஆனால் நான் அதை> 0 என்று அது 0 அல்லது <0 இருக்க போவதில்லை என்று கூட

463
00:28:25,000 --> 00:28:29,000
நான் இன்னமும் 0 செய்ய போகிறேன், அது, <0

464
00:28:29,000 --> 00:28:33,000
எனவே நான் உண்மையில் நான் இல்லை என்று என்பதெல்லாம் உள்ளே செல்கிறேன்

465
00:28:33,000 --> 00:28:38,000
நான் ஏற்கனவே இந்த நிலையில் எந்த பூர்த்தி செய்ய போவதில்லை என்று எனக்கு தெரியும்.

466
00:28:38,000 --> 00:28:41,000
நான் அறிக்கை வேறு, வேறு, நீங்கள் பயன்படுத்தலாம்.

467
00:28:41,000 --> 00:28:45,000
X = 0 நான் நேர்மறை அச்சிட அது அடிப்படையில் கூறுகிறார்.

468
00:28:45,000 --> 00:28:48,000
அது இல்லை என்றால், நான் இந்த சோதனை போகிறேன்.

469
00:28:48,000 --> 00:28:51,000
இது 2 இருந்தால் நான் இதை செய்ய போகிறேன்.

470
00:28:51,000 --> 00:28:54,000
நான் x = 2 செய்தால் அடிப்படையில் நீங்கள் சொல்ல முடியும்

471
00:28:54,000 --> 00:28:57,000
(x> 0) என்றால், ஆமாம், இந்த அச்சிட.

472
00:28:57,000 --> 00:29:00,000
இப்போது நான் அதை> 0 என்று அந்த என்று முதலில் நீங்கள் திருப்தி

473
00:29:00,000 --> 00:29:02,000
நான் கூட இந்த குறியீடு இயக்க போவதில்லை.

474
00:29:02,000 --> 00:29:09,000
இந்த பயன்படுத்தினால் குறியீடு 3 மடங்கு வேகமாக, உண்மையில், வேகமாக இயங்கும்.

475
00:29:09,000 --> 00:29:11,000
நாங்கள் சுமார் மற்றும் அல்லது கற்று.

476
00:29:11,000 --> 00:29:15,000
நான் Lexi ஏற்கனவே அவர்களை பற்றி இந்த வழியாக செல்ல போவதில்லை.

477
00:29:15,000 --> 00:29:17,000
| ஆபரேட்டர் | அது && மற்றும் தான்.

478
00:29:17,000 --> 00:29:21,000
>> நான் சொல்கிறேன் மட்டும் நீங்கள் 3 நிபந்தனைகளை போது கவனமாக இருக்க வேண்டும்.

479
00:29:21,000 --> 00:29:24,000
இது மிகவும் குழப்பமான ஏனெனில் நீங்கள் ஒரு நிபந்தனை போது அடைப்புக்குறிக்குள் பயன்படுத்த

480
00:29:24,000 --> 00:29:27,000
மற்றொரு ஒன்று அல்லது மற்றொரு.

481
00:29:27,000 --> 00:29:30,000
உங்கள் நிலைமைகள் போடுவது என்று இருக்கும் அடைப்புக்குறிக்குள் பயன்படுத்த

482
00:29:30,000 --> 00:29:34,000
அந்த வழக்கில், உதாரணமாக, நீங்கள் கற்பனை ஏனெனில் அந்த

483
00:29:34,000 --> 00:29:38,000
இது முதல் நிலை மற்றும் ஒன்று அல்லது வேறு இருக்க முடியாது

484
00:29:38,000 --> 00:29:41,000
அல்லது 2 ஒரு இணைந்து நிலைமைகள் மற்றும்

485
00:29:41,000 --> 00:29:45,000
அல்லது மூன்றாவது ஒரு, அதனால் தான் கவனமாக இருக்க வேண்டும்.

486
00:29:45,000 --> 00:29:48,000
இறுதியாக, நாம் சுவிட்சுகள் பற்றி பேசினார்.

487
00:29:48,000 --> 00:29:53,000
நீங்கள் ஒரு மாறி போது ஒரு சுவிட்சை மிகவும் பயனுள்ளதாக இருக்கும்.

488
00:29:53,000 --> 00:29:55,000
நாம் உங்களுக்கு n போன்ற ஒரு மாறி இருக்கிறது என்று

489
00:29:55,000 --> 00:29:59,000
அந்த 0, 1, அல்லது 2 முடியும், மற்றும் அந்த வழக்குகளின் ஒவ்வொரு

490
00:29:59,000 --> 00:30:01,000
நீங்கள் ஒரு பணி செய்ய போகிறோம்.

491
00:30:01,000 --> 00:30:04,000
நீங்கள் மாறி மாறி சொல்ல முடியாது, அது சுட்டிக்காட்டுகிறது

492
00:30:04,000 --> 00:30:08,000
மதிப்பு பின்னர், value1 போல் நான் செய்ய போகிறேன் என்று

493
00:30:08,000 --> 00:30:12,000
பின்னர் நான் உடைத்து, அதில் நான் மற்ற நேரங்களில் எந்த பார்க்க போவதில்லை என்பது

494
00:30:12,000 --> 00:30:15,000
நாம் ஏற்கனவே அந்த வழக்கு திருப்தி ஏனெனில்

495
00:30:15,000 --> 00:30:20,000
பின்னர் value2 தான், நான் ஒரு முன்னிருப்பு மாற்றம் செய்யலாம்.

496
00:30:20,000 --> 00:30:24,000
அதை நான் அந்த சமயங்களில் எந்த திருப்தி இல்லை என்றால், அந்த பொருள்

497
00:30:24,000 --> 00:30:29,000
நான் வேறு ஏதாவது செய்ய போகிறேன், ஆனால் அந்த விருப்ப என்று.

498
00:30:29,000 --> 00:30:36,000
எனக்கு எல்லா என்று. இப்போது டாமி சாப்பிடலாம்.

499
00:30:36,000 --> 00:30:41,000
எல்லாம் சரி, இந்த வாரம் 3-ish போகிறது.

500
00:30:41,000 --> 00:30:45,000
இந்த நாங்கள் பயன்படுத்தப்படுகிறது crypto, நோக்கம், வரிசைகள், மூடி இருக்க வேண்டும் தலைப்புகள் உள்ளன.

501
00:30:45,000 --> 00:30:49,000
Crypto மீது ஒரு விரைவு வார்த்தை. நாம் இந்த வீட்டில் சுத்தியலால் அடித்து போவதில்லை.

502
00:30:49,000 --> 00:30:52,000
>> நாம் pset 2 இந்த செய்தார், ஆனால் வினாடி வினா உங்களுக்கு வித்தியாசம் தெரியும் உறுதி

503
00:30:52,000 --> 00:30:54,000
சீசர் மறைக்குறியீடு மற்றும் வைஜெனேர் மறைக்குறியீடு இடையே,

504
00:30:54,000 --> 00:30:57,000
அந்த மறைக்குறியீடுகள் வேலை மற்றும் அது குறியாக்க போல் எப்படி

505
00:30:57,000 --> 00:30:59,000
அந்த 2 மறைக்குறியீடுகள் பயன்படுத்தி மற்றும் டிக்ரிப்ட் உரை.

506
00:30:59,000 --> 00:31:03,000
நினைவில் வைத்து கொள்ளுங்கள், சீசர் மறைக்குறியீடு எளிமையாக, அதே அளவு ஒவ்வொரு தன்மையை சுழல்கிறது

507
00:31:03,000 --> 00:31:06,000
எழுத்துக்களில் கடிதங்கள் எண்ணிக்கை உங்களுக்கு மோட் உறுதி செய்யும்.

508
00:31:06,000 --> 00:31:09,000
மற்றும் வைஜெனேர் மறைக்குறியீடு, மறுபுறம், ஒவ்வொரு தன்மையை சுழல்கிறது

509
00:31:09,000 --> 00:31:12,000
வேறு அளவு, இதனால் கூறி விட

510
00:31:12,000 --> 00:31:15,000
3 வைஜெனேர் ஒவ்வொரு தன்மையை சுழற்சி முறையில் ஒவ்வொரு தன்மையை சுழற்ற

511
00:31:15,000 --> 00:31:17,000
சில முக்கிய பொறுத்து வெவ்வேறு அளவு

512
00:31:17,000 --> 00:31:20,000
முக்கிய ஒவ்வொரு கடிதம் சில வெவ்வேறு அளவு குறிக்கப்படுகிறது

513
00:31:20,000 --> 00:31:26,000
மூலம் தெளிவான உரை சுழற்ற.

514
00:31:26,000 --> 00:31:28,000
மாறி நோக்கம் பற்றி முதலில் பேச்சு நாம்.

515
00:31:28,000 --> 00:31:30,000
மாறிகளின் 2 வெவ்வேறு வகைகள் உள்ளன.

516
00:31:30,000 --> 00:31:33,000
நாங்கள் உள்ளூர் மாறிகள் வேண்டும், மற்றும் இந்த வரையறை செய்யப்பட போகிறோம்

517
00:31:33,000 --> 00:31:36,000
வெளியே முக்கிய அல்லது எந்த செயல்பாடு அல்லது தொகுதி வெளியே,

518
00:31:36,000 --> 00:31:39,000
இந்த உங்கள் திட்டத்தில் எங்கேயும் அணுக முடியும்.

519
00:31:39,000 --> 00:31:41,000
நீங்கள் ஒரு செயல்பாடு மற்றும் அந்த விழாவில் ஒரு சுழற்சி இருந்தால்

520
00:31:41,000 --> 00:31:44,000
பெரிய உலகளாவிய மாறி எங்கும் அணுகலாம்.

521
00:31:44,000 --> 00:31:48,000
ஒரு உள்ளூர் மாறி, மறுபுறம், அது வரையறுக்கப்பட்ட அமைந்துள்ள இடத்திற்கு ஆகியவற்றை நோக்காகக்கொண்ட உள்ளது.

522
00:31:48,000 --> 00:31:53,000
>> நீங்கள் இங்கே ஒரு செயல்பாடு இருந்தால், உதாரணமாக, நாம், இந்த செயல்பாடு கிராம் வேண்டும்

523
00:31:53,000 --> 00:31:56,000
மற்றும் கிராம் உள்ளே y என்று இங்கே ஒரு மாறி, இல்லை

524
00:31:56,000 --> 00:31:58,000
மற்றும் இந்த ஒரு உள்ளூர் மாறி இருக்கிறது என்று அர்த்தம்.

525
00:31:58,000 --> 00:32:00,000
இந்த மாறி y என்று கூட

526
00:32:00,000 --> 00:32:03,000
இந்த மாறி இந்த 2 செயல்பாடுகளை Y அழைக்கப்படுகிறது

527
00:32:03,000 --> 00:32:06,000
ஒருவருக்கொருவர் உள்ளூர் மாறிகள் என்ன தெரியாது.

528
00:32:06,000 --> 00:32:10,000
மறுபுறம், இங்கு நாம், int x = 5 என்று

529
00:32:10,000 --> 00:32:12,000
இந்த எந்த செயல்பாடு நோக்கம் வெளியே.

530
00:32:12,000 --> 00:32:16,000
இது முக்கிய நோக்கம் வெளியில், இந்த உலக மாறி உள்ளது.

531
00:32:16,000 --> 00:32:20,000
அல்லது x + - நான் x சொல்லும் போது இந்த 2 செயல்பாடுகளை என்று உள்ளே பொருள்

532
00:32:20,000 --> 00:32:26,000
நான் இந்த y இந்த y பல்வேறு மாறிகளை மேற்கொள்கின்ற அதே x அணுகும்.

533
00:32:26,000 --> 00:32:30,000
உலக மாறி மற்றும் உள்ளூர் மாறி இடையே வேறுபாடு என்று.

534
00:32:30,000 --> 00:32:33,000
இதுவரை வடிவமைப்பு விஷயத்தில், சில நேரங்களில் அது அநேகமாக ஒரு நல்ல யோசனை

535
00:32:33,000 --> 00:32:37,000
உன்னால் முடிந்த போதெல்லாம் மாறிகள் உள்ளூர் வைக்க

536
00:32:37,000 --> 00:32:39,000
கொண்ட முதல் உலக மாறிகள் ஒரு கூட்டத்தை உண்மையில் குழப்பமான பெற முடியும்.

537
00:32:39,000 --> 00:32:42,000
நீங்கள் செயல்பாடுகளை ஒரு கொத்து இருந்தால் அனைத்து அதையே மாற்றுதல்

538
00:32:42,000 --> 00:32:45,000
இந்த விழாவில் தற்செயலாக இந்த உலக திருத்தங்கள் என்ன நீங்கள், மறப்பது

539
00:32:45,000 --> 00:32:47,000
இந்த மற்ற செயல்பாடு, அது பற்றி தெரியாது

540
00:32:47,000 --> 00:32:50,000
நீங்கள் இன்னும் குறியீடு பெறுவது மற்றும் அதை அழகாக குழப்பமான கிடைக்கும்.

541
00:32:50,000 --> 00:32:53,000
உன்னால் முடிந்த போதெல்லாம் மாறிகள் உள்ளூர் வைத்து

542
00:32:53,000 --> 00:32:56,000
ஒரு நல்ல வடிவமைப்பு ஆகும்.

543
00:32:56,000 --> 00:33:00,000
வரிசைகள், ஞாபகமிருக்கட்டும், வெறுமனே அதே வகை உறுப்புகள் பட்டியல்கள் உள்ளன.

544
00:33:00,000 --> 00:33:04,000
சிஐ உள்ளே ஹலோ, 1, 2.0 போன்ற ஒரு பட்டியலை முடியாது.

545
00:33:04,000 --> 00:33:06,000
நாம் தான் அதை செய்ய முடியாது.

546
00:33:06,000 --> 00:33:11,000
>> நாம் சி ஒரு அணி அறிவிக்க போது உறுப்புகள் அனைத்தும் ஒரே வகையாக இருக்க வேண்டும்.

547
00:33:11,000 --> 00:33:14,000
இங்கே நான் 3 முழுஎண்களின் வரிசை உள்ளது.

548
00:33:14,000 --> 00:33:18,000
இங்கே நான் வரிசை நீளம் உள்ளது, ஆனால் நான் இந்த இலக்கணத்தை அது பிரகடனம் என்றால்

549
00:33:18,000 --> 00:33:21,000
நான் கூறுகள் அனைத்தையும் நான் தொழில்நுட்பரீதியாக இந்த 3 தேவையில்லை என்பதை குறிப்பிட வேண்டும்.

550
00:33:21,000 --> 00:33:25,000
தொகுப்பி வரிசை இருக்க வேண்டும் என்பதை பெரிய கண்டுபிடிக்க போதுமான புத்திசாலி.

551
00:33:25,000 --> 00:33:28,000
இப்போது நான் ஒரு வரிசைக்கு மதிப்பு அல்லது அமைக்க வேண்டும் போது

552
00:33:28,000 --> 00:33:30,000
இந்த செய்ய தொடரியல் ஆகும்.

553
00:33:30,000 --> 00:33:33,000
, நினைவில் ஏனெனில் இந்த உண்மையில் அணியின் இரண்டாவது உறுப்பு மாற்ற வேண்டும்,

554
00:33:33,000 --> 00:33:36,000
எண் 1 இல்லை, 0 தொடங்குகிறது.

555
00:33:36,000 --> 00:33:42,000
நான் அந்த மதிப்பை படிக்க விரும்பினால் நான் அப்படி சொல்லலாம் int x = வரிசை [1].

556
00:33:42,000 --> 00:33:44,000
நான் அந்த மதிப்பை அமைக்க விரும்பினால் அல்லது, போன்ற நான், இங்கே என்ன செய்து கொண்டிருக்கிறேன்

557
00:33:44,000 --> 00:33:47,000
நான் வரிசை [1] கூற முடியும் = 4.

558
00:33:47,000 --> 00:33:50,000
அவர்கள் குறியீட்டு மூலம் கூறுகள் அணுகும் முறை

559
00:33:50,000 --> 00:33:52,000
அல்லது தங்கள் நிலையை அல்லது அவர்கள் வரிசையில் இருக்கும்,

560
00:33:52,000 --> 00:33:57,000
அந்த பட்டியலை 0 தொடங்குகிறது.

561
00:33:57,000 --> 00:34:00,000
நாங்கள், வரிசைகளின் வரிசைகள் முடியும்

562
00:34:00,000 --> 00:34:03,000
இந்த பல பரிமாண அணிகளில் அழைக்கப்படுகிறது.

563
00:34:03,000 --> 00:34:05,000
நாம் பல பரிமாண அணிகளில் போது

564
00:34:05,000 --> 00:34:07,000
நாம், வரிசை மற்றும் பத்தி போன்ற ஏதாவது செய்யலாம் என்று

565
00:34:07,000 --> 00:34:11,000
மற்றும் இந்த காண்பதற்கு அல்லது அது குறித்து யோசித்து ஒரு வழி.

566
00:34:11,000 --> 00:34:14,000
நான் பல பரிமாண அணிகளில் வேண்டும் என்று நான் தேவைப்படும் தொடங்க போகிறேன் என்றால்

567
00:34:14,000 --> 00:34:17,000
அதிகமான 1 குறியீட்டெண் ஏனெனில் நான் ஒரு கட்டம் இருந்தால்

568
00:34:17,000 --> 00:34:19,000
இப்போது நீங்கள் தான் என்ன வரிசை என்று எங்களுக்கு ஒரு எண் கொடுக்க முடியாது.

569
00:34:19,000 --> 00:34:22,000
என்று உண்மையிலேயே நமக்கு எண்கள் பட்டியல் கொடுக்க நடக்கிறது.

570
00:34:22,000 --> 00:34:25,000
நாம் இங்கே இந்த வரிசை வேண்டும் என்று.

571
00:34:25,000 --> 00:34:30,000
நான் கட்டம் என்று ஒரு அணி வேண்டும், மற்றும் நான், இது 2 வரிசைகள் மற்றும் 3 நெடுவரிசைகள் சொல்கிறேன்

572
00:34:30,000 --> 00:34:32,000
எனவே இது காண்பதற்கு ஒரு வழி.

573
00:34:32,000 --> 00:34:37,000
நான் [1] உள்ள உறுப்பு பெற வேண்டும் என்று சொல்லும் போது [2]

574
00:34:37,000 --> 00:34:41,000
இந்த வரிசையில் முதல் மற்றும் பிறகு நெடுவரிசைகள் ஏனெனில் என்று அர்த்தம்

575
00:34:41,000 --> 00:34:44,000
நான் 1 என்று முதல் 1 வரிசையை செல்ல போகிறேன்.

576
00:34:44,000 --> 00:34:49,000
>> நான் பத்தியில் 2 இங்கே வந்து போகிறேன், நான் மதிப்பு 6 கொண்டு வர போகிறேன்.

577
00:34:49,000 --> 00:34:51,000
இதில்?

578
00:34:51,000 --> 00:34:55,000
பல பரிமாண வரிசைகள், ஞாபகமிருக்கட்டும், தொழில்நுட்ப வரிசைகளின் ஒரு வரிசை இருக்கும்.

579
00:34:55,000 --> 00:34:57,000
நாம் வரிசைகளின் வரிசைகளின் வரிசைகள் முடியும்.

580
00:34:57,000 --> 00:35:00,000
நாம் என்ன வைத்திருக்க முடியும், ஆனால் பற்றி சிந்திக்க உண்மையில் ஒரு வழி

581
00:35:00,000 --> 00:35:03,000
இந்த அமைக்கப்பட்டன வருகிறது என்ன நடக்கிறது என்பதை பார்க்க வேண்டும்

582
00:35:03,000 --> 00:35:09,000
இந்த மாதிரி ஒரு கட்டத்தில்.

583
00:35:09,000 --> 00:35:12,000
நாம் செயல்படும் வரிசைகள் போகும்போது, அவர்கள் நடந்து செல்கிறோம்

584
00:35:12,000 --> 00:35:16,000
நாம் செயல்பாடுகளை வழக்கமான மாறிகள் போகும்போது விட வித்தியாசமாக சிறிது

585
00:35:16,000 --> 00:35:18,000
ஒரு முழு எண்ணாக அல்லது ஒரு மிதவை கடந்து போல.

586
00:35:18,000 --> 00:35:21,000
நாம் ஒரு முழு எண்ணாக அல்லது கரி அல்லது மற்ற தரவு எந்த வகையான போகும்போது

587
00:35:21,000 --> 00:35:24,000
நாம் மட்டும் செயல்பாட்டை மேம்படுத்த வேண்டும் பார்த்துக்கொண்டோம்

588
00:35:24,000 --> 00:35:28,000
மாற்றம் வரை பிரச்சாரம் போவதில்லை என்று மாறி மதிப்பு

589
00:35:28,000 --> 00:35:32,000
அழைப்பு செயல்பாடு.

590
00:35:32,000 --> 00:35:35,000
ஒரு வரிசைக்கு கொண்டு, மறுபுறம், என்று நடக்கும்.

591
00:35:35,000 --> 00:35:39,000
நான் சில செயல்பாடு ஒரு வரிசையில் கடந்து, அந்த செயல்பாடு, உறுப்புகள் சில மாற்றங்கள் செய்தால்

592
00:35:39,000 --> 00:35:43,000
நான் என்ற அந்த செயல்பாடு வரை திரும்பியவுடன்

593
00:35:43,000 --> 00:35:47,000
என் வரிசை இப்போது வேறு இருக்க போகிறது, மற்றும் அந்த சொல்லகராதி

594
00:35:47,000 --> 00:35:50,000
நாம் பிறகு பார்க்கலாம் என்பது வரிசைகள், குறிப்பு நிறைவேற்றப்பட்டது.

595
00:35:50,000 --> 00:35:53,000
இந்த எப்படி சுட்டிகள் வேலை, அங்கு இந்த அடிப்படை தரவு வகைகள், தொடர்புடைய

596
00:35:53,000 --> 00:35:55,000
மறுபுறம், மதிப்பு நிறைவேற்றப்பட்டது.

597
00:35:55,000 --> 00:35:59,000
>> நாம் சில மாறி நகலை உருவாக்கும் பின்னர் நகல் கடந்து செல்லும் என்று நினைக்க முடியாது.

598
00:35:59,000 --> 00:36:01,000
அதை நாம் என்று மாறி என்ன செய்ய தேவையில்லை.

599
00:36:01,000 --> 00:36:06,000
அழைப்பு செயல்பாடு அது மாற்றப்பட்டது என்பதை மாட்டேன்.

600
00:36:06,000 --> 00:36:10,000
வரிசைகள் என்று தொடர்பாக வேறுபட்ட ஒரு சிறிய பிட்.

601
00:36:10,000 --> 00:36:13,000
நாம் தான் பார்த்தேன் உதாரணம், முக்கிய வெறுமனே ஒரு செயல்பாடு ஆகும்

602
00:36:13,000 --> 00:36:15,000
அந்த 2 வாக்குவாதம் எடுத்து கொள்ளலாம்.

603
00:36:15,000 --> 00:36:20,000
முக்கிய செயல்பாடு முதல் வாதம், argc, அல்லது வாதங்கள் எண்ணிக்கை

604
00:36:20,000 --> 00:36:23,000
இரண்டாவது வாதம், argv அழைக்கப்படுகிறது

605
00:36:23,000 --> 00:36:27,000
மற்றும் அந்த வாதங்கள் உண்மையான மதிப்புகள்.

606
00:36:27,000 --> 00:36:30,000
நாம், நான் this.c என்று ஒரு திட்டம் வேண்டும் என்று

607
00:36:30,000 --> 00:36:34,000
நான் இந்த செய்ய சொல்ல, நான் கட்டளை வரியில் இந்த இயக்க போகிறேன்.

608
00:36:34,000 --> 00:36:38,000
இப்போது என் திட்டத்தின் சில வாக்குவாதம் அனுப்ப, இந்த என்று

609
00:36:38,000 --> 00:36:42,000
நான் எதோ சொல்ல முடியும். / இந்த cs 50 ஆகும்.

610
00:36:42,000 --> 00:36:45,000
இந்த நாங்கள் முனையத்தில் ஒவ்வொரு நாளும் டேவிட் செய்ய நினைத்து தான்.

611
00:36:45,000 --> 00:36:48,000
அந்த திட்டத்தின் ஆனால் இப்போது முக்கிய செயல்பாடு உள்ளே

612
00:36:48,000 --> 00:36:52,000
இந்த மதிப்புகள், அதனால் argc 4.

613
00:36:52,000 --> 00:36:56,000
உண்மையில் நாங்கள் மட்டுமே cs 50 ஆகும் கடந்து செல்லும் நீங்கள், ஏனெனில் அது ஒரு சிறிய குழப்பம் இருக்கலாம்.

614
00:36:56,000 --> 00:36:58,000
என்று மட்டும் 3 தான்.

615
00:36:58,000 --> 00:37:02,000
ஆனால் நினைவில் அந்த argv முதல் உறுப்பு அல்லது முதல் வாதம்

616
00:37:02,000 --> 00:37:05,000
விழாவில் தன்னை பெயர்.

617
00:37:05,000 --> 00:37:07,190
அதனால், நாம் இங்கே 4 விஷயங்கள் என்று அர்த்தம்

618
00:37:07,190 --> 00:37:10,530
மற்றும் முதல் உறுப்பு. / இந்த போகிறது.

619
00:37:10,530 --> 00:37:12,970
இந்த ஒரு சரம் குறிப்பிடப்படுகின்றன.

620
00:37:12,970 --> 00:37:18,590
பின்னர் மீதமுள்ள தனிமங்கள் நாம் திட்டத்தின் பெயர் பின்னர் தட்டச்சு என்ன.

621
00:37:18,590 --> 00:37:22,720
எனவே ஒதுக்கி போல் ஒரு, நாம் ஒருவேளை pset 2 பார்த்த போது,

622
00:37:22,720 --> 00:37:28,780
சரம் 50 முழு 50 ≠ என்று ஞாபகம்.

623
00:37:28,780 --> 00:37:32,520
எனவே, இப்படி ஏதாவது சொல்ல முடியாது 'int x = argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> இந்த ஒரு சரம், ஏனெனில் அது தான், உணர்வு செய்ய போவதில்லை, இந்த ஒரு முழு எண் ஆகும்.

625
00:37:36,470 --> 00:37:38,510
நீங்கள் 2 இடையே மாற்ற வேண்டும் என்றால், ஞாபகமிருக்கட்டும், நாங்கள் செல்கிறோம்

626
00:37:38,510 --> 00:37:40,810
atoi என்று இந்த மாய செயல்பாடு உள்ளது.

627
00:37:40,810 --> 00:37:46,270
ஒரு சரம் எடுத்து அந்த சரம் உள்ளே குறிப்பிடப்படுகின்றன முழு கொடுக்கிறது.

628
00:37:46,270 --> 00:37:48,360
அதனால், வினாடி வினா மீது செய்ய எளிதான தவறு

629
00:37:48,360 --> 00:37:51,590
இந்த தானாகவே சரியான வகை என்று நினைத்து.

630
00:37:51,590 --> 00:37:53,860
ஆனால் இந்த எப்போதும் சரங்களை இருப்பார் என்று எனக்கு தெரியும்

631
00:37:53,860 --> 00:38:00,920
சரம் மட்டுமே ஒரு முழு எண் அல்லது ஒரு பாத்திரம் அல்லது ஒரு மிதவை கொண்டுள்ளது கூட.

632
00:38:00,920 --> 00:38:03,380
எனவே இப்போது நேரம் இயங்கும் பற்றி பேசுகிறேன்.

633
00:38:03,380 --> 00:38:06,700
நாம் இந்த வேடிக்கையான விஷயம் என்று இந்த வழிமுறைகளை போது,

634
00:38:06,700 --> 00:38:11,580
இது, கேள்வி கேட்க மிகவும் பயனுள்ளதாக இருக்கும் "அவர்கள் எவ்வளவு காலம் எடுக்கும்?"

635
00:38:11,580 --> 00:38:15,500
நாம் எந்த அறிகுறியும் குறியீடு எனப்படும் ஒன்றை என்று குறிக்கின்றன.

636
00:38:15,500 --> 00:38:18,430
நன்றாக, நாம் நமது வழிமுறையை கொடுக்க சொல்கிறேன் - இந்த அர்த்தம்

637
00:38:18,430 --> 00:38:20,840
சில உண்மையில், உண்மையில் பெரிய உள்ளீடு.

638
00:38:20,840 --> 00:38:23,840
நாம் கேள்வி கேட்க விரும்புகிறேன், "எவ்வளவு நேரம் எடுத்து செல்வது?

639
00:38:23,840 --> 00:38:26,370
எப்படி பல படிகளை அதை இயக்க நமது வழிமுறையை எடுக்கும்

640
00:38:26,370 --> 00:38:29,980
உள்ளீடு அளவு செயல்பாடாக? "

641
00:38:29,980 --> 00:38:33,080
நாம் இயக்க நேரம் விவரிக்க முடியாது முதல் வழி பெரிய பெ உள்ளது

642
00:38:33,080 --> 00:38:35,380
இந்த நமது மோசமான இயங்கும் நேரம்.

643
00:38:35,380 --> 00:38:38,590
நாம் ஒரு வரிசை வரிசைப்படுத்த வேண்டும் என்றால், நாம் நமது வழிமுறையை வரிசை கொடுக்க

644
00:38:38,590 --> 00:38:41,000
இது ஏறு வரிசையில் இருக்க வேண்டும் என்று, இறங்கு வரிசையில் தான்

645
00:38:41,000 --> 00:38:43,130
அந்த மோசமான இருக்க போகிறது.

646
00:38:43,130 --> 00:38:49,800
இந்த எங்கள் வழிமுறை எடுக்கும் நேரம் அதிகபட்ச நீளம் கட்டப்படுகிறது எங்கள் மேல் ஆகும்.

647
00:38:49,800 --> 00:38:54,740
மறுபுறம், இந்த Ω சிறந்த வழக்கு இயங்கும் நேரம் விவரிக்க போகிறார்.

648
00:38:54,740 --> 00:38:58,210
நாம் ஒரு வரிசையாக்க படிமுறையின் ஒரு ஏற்கனவே வரிசையாக்கம் வரிசை கொடுக்க நீங்கள்,

649
00:38:58,210 --> 00:39:00,940
இது வரிசைப்படுத்த, அது எவ்வளவு நேரம் ஆகும்?

650
00:39:00,940 --> 00:39:06,610
இந்த, பின்னர், நேரம் இயங்கும் ஒரு குறைந்த பிணைப்பு விவரிக்கிறது.

651
00:39:06,610 --> 00:39:10,980
இங்கு சில பொதுவான இயங்கும் முறை விவரிக்கும் சில வார்த்தைகள் உள்ளன.

652
00:39:10,980 --> 00:39:13,120
இந்த ஏறுவரிசையில் உள்ளன.

653
00:39:13,120 --> 00:39:16,060
நாம் வேகமாக இயங்கும் நேரம் இடைவிடாமல் அழைக்கப்படுகிறது.

654
00:39:16,060 --> 00:39:19,800
>> நாம் நமது வழிமுறையை கொடுக்க எத்தனை சக்திகள் இல்லை, அதாவது

655
00:39:19,800 --> 00:39:22,280
எங்கள் அணி தான் வரிசைப்படுத்துவதன், எப்படி பெரிய விஷயம் இல்லை

656
00:39:22,280 --> 00:39:26,510
அல்லது நாம் வரிசைக்கு செய்கிறோம் என்ன செய்து எப்போதும் நேரம் அதே அளவு எடுக்கும்.

657
00:39:26,510 --> 00:39:30,270
நாம் ஒரு நிலையான ஒரு 1, என்று குறிக்கலாம்.

658
00:39:30,270 --> 00:39:32,410
நாங்கள் மடக்கை ரன் நேரம் பார்த்து.

659
00:39:32,410 --> 00:39:34,800
எனவே இரும தேடல் போல, மடக்கையாக

660
00:39:34,800 --> 00:39:37,140
நாம் பாதி ஒவ்வொரு முறையும் பிரச்சனை வெட்டி அங்கு

661
00:39:37,140 --> 00:39:40,970
பின்னர் விஷயங்கள் அங்கு இருந்து அதிக கிடைக்கும்.

662
00:39:40,970 --> 00:39:43,580
நீங்கள் எந்த காரணியாலான வழிமுறையின் ஒரு ஓ எழுதி என்றால்,

663
00:39:43,580 --> 00:39:47,850
ஒருவேளை நீங்கள் உங்கள் நாள் வேலை இந்த கருத கூடாது.

664
00:39:47,850 --> 00:39:53,910
நாம் இயங்கும் முறை ஒப்பிடும் போது இது மனதில் இந்த விஷயங்களை வைத்து முக்கியம்.

665
00:39:53,910 --> 00:39:57,760
நான் ஒரு ஓ (n) என்று வழிமுறை, வேறு யாரோ என்றால்

666
00:39:57,760 --> 00:40:03,590
ஓ ஒரு வழிமுறை (2n) இந்த உண்மையில் தொலைத்தொடுகோட்டு சமமானதாக இருக்கும்.

667
00:40:03,590 --> 00:40:06,590
நாம் eleventy பில்லியன் போன்ற ஒரு பெரிய எண் இருக்கும் n நீங்கள்:

668
00:40:06,590 --> 00:40:13,090
நாம் eleventy பில்லியன் போன்ற ஏதாவது + 3 eleventy பில்லியன் ஒப்பிட்டு போது,

669
00:40:13,090 --> 00:40:17,640
திடீரென்று அந்த +3 உண்மையில் இனி ஒரு பெரிய வித்தியாசம் இல்லை.

670
00:40:17,640 --> 00:40:20,980
நாம் இந்த பொருட்களை சமமான கருத தொடங்க போகிறோம் அதனால் தான்.

671
00:40:20,980 --> 00:40:24,220
இங்கே இந்த மாறிலிகள் போன்ற விஷயங்களை மிக, அங்கு 2 x இந்த நேரம், அல்லது ஒரு 3 சேர்க்கும்

672
00:40:24,220 --> 00:40:27,180
இந்த வெறும் மாறிலிகள் உள்ளன, இந்த வரை விட்டு செல்கிறோம்.

673
00:40:27,180 --> 00:40:32,480
இந்த ரன் முறை அனைத்து 3 அவர்கள் ஓ (n) என்று கூறி தான் அதனால் தான்.

674
00:40:32,480 --> 00:40:37,490
நாங்கள் 2 மற்ற இயக்க முறை இருந்தால் இதேபோல்,, ஓ (n ³ + 2n ²), நாம் சேர்க்க முடியும் என்று நாம்

675
00:40:37,490 --> 00:40:42,070
பின்னர் + n + 7, மற்றும் நாம் தான் ஓ என்று மற்றொரு ரன் நேரம் (n ³) உள்ளது.

676
00:40:42,070 --> 00:40:46,290
இதே இல்லை - இந்த ஏனெனில் மீண்டும், இந்த ஒரே விஷயம் தான்.

677
00:40:46,290 --> 00:40:49,840
இதே விஷயங்கள், மன்னிக்கவும். எனவே இந்த ஒரே காரணம்

678
00:40:49,840 --> 00:40:53,090
இந்த n ³ இந்த 2n ² ஆதிக்கம் செலுத்த போகிறது.

679
00:40:53,090 --> 00:40:59,130
>> நாம் ஓ (n ³) மற்றும் ஓ போன்ற முறை இயக்க வேண்டும் என்றால் என்ன ஒரே விஷயம் (n ²)

680
00:40:59,130 --> 00:41:02,820
இந்த n ³ இந்த n ² விட மிக பெரிய காரணம்.

681
00:41:02,820 --> 00:41:05,470
நாம் இசைநிபுணர்களின் இருந்தால் அதனால், திடீரென்று இந்த, பிரச்சினையில்லை தொடங்கும்

682
00:41:05,470 --> 00:41:08,280
நாம் இங்கு இருக்கும் ஆனால் நாம் மட்டும், காரணிகளை கையாளும் போது

683
00:41:08,280 --> 00:41:12,810
அது அவர்கள் வெளியே விட்டு போகிறீர்கள் ஏனெனில் பிரச்சினையில்லை போவதில்லை.

684
00:41:12,810 --> 00:41:16,760
நாம் இதுவரை பார்த்த வழிமுறைகளை சில பார்க்கலாம்

685
00:41:16,760 --> 00:41:19,260
அவர்கள் நடத்தும் முறை பற்றி பேச.

686
00:41:19,260 --> 00:41:23,850
ஒரு பட்டியலில் பல தேடும் முதல் வழி, நாம் பார்த்த, நேரியல் தேடல் இருந்தது.

687
00:41:23,850 --> 00:41:26,950
மேலும் ஒருபடி தேடல் செயல்படுத்த சூப்பர் நேர்மையானவன்.

688
00:41:26,950 --> 00:41:30,490
நாம் ஒரு பட்டியல் உள்ளது, மற்றும் நாம் பட்டியலில் ஒவ்வொரு உறுப்பு பார்க்க போகிறோம்

689
00:41:30,490 --> 00:41:34,260
நாம் எண் வரும் வரை நாம் தேடும்.

690
00:41:34,260 --> 00:41:38,370
அதனால் அதாவது மிக மோசமான நிலையில், இந்த ஓ (n).

691
00:41:38,370 --> 00:41:40,860
உறுப்பு என்றால் இங்கு மோசமான இருக்க முடியும்

692
00:41:40,860 --> 00:41:45,710
கடந்த உறுப்பு, பின்னர் நேரியல் தேடல் பயன்படுத்தி நாம் ஒவ்வொரு உறுப்பு பார்க்க வேண்டும்

693
00:41:45,710 --> 00:41:50,180
நாம் அது பட்டியலில் உண்மையில் என்று தெரியும் பொருட்டு கடந்த ஒரு பெற வரை.

694
00:41:50,180 --> 00:41:52,910
நாங்கள் பாதியிலேயே கைவிட்டு சொல்ல முடியாது, "இது அங்கு அநேகமாக இல்லை."

695
00:41:52,910 --> 00:41:55,980
நேரியல் தேடல் நாம் முழு விஷயத்தை கவனிக்க வேண்டும்.

696
00:41:55,980 --> 00:41:59,090
சிறந்த வழக்கு இயங்கும் நேரம், மறுபுறம், மாறிலி

697
00:41:59,090 --> 00:42:04,200
சிறந்த வழக்கில் நாம் தேடும் உறுப்பு வெறும் பட்டியலில் முதல் ஒரு காரணம்.

698
00:42:04,200 --> 00:42:08,930
அது நமக்கு சரியாக 1 படி, பட்டியலில் எப்படி பெரிய விஷயம் இல்லை எடுக்க நடக்கிறது

699
00:42:08,930 --> 00:42:12,140
நாம் முதல் உறுப்பு ஒவ்வொரு முறை விரும்பினால்.

700
00:42:12,140 --> 00:42:15,390
>> எனவே நீங்கள் தேடும்போது, ஞாபகமிருக்கட்டும், இது எங்கள் பட்டியலில் வரிசைப்படுத்தப்பட்ட வேண்டும் என்று அவசியம் இல்லை.

701
00:42:15,390 --> 00:42:19,430
நாம் சாதாரணமாக ஒவ்வொரு உறுப்பு மேல் பார்க்க போகிறோம், அது உண்மையில் இல்லை, ஏனெனில்

702
00:42:19,430 --> 00:42:23,560
என்ன பொருட்டு அந்த உறுப்புகள் இருக்கும்

703
00:42:23,560 --> 00:42:28,110
மேலும் அறிவார்ந்த தேடல் வழிமுறை இரும தேடல் போன்ற ஒன்று.

704
00:42:28,110 --> 00:42:31,500
நீ போகிறாய் நினைவில், பைனரி தேடல் அமல்படுத்துவது

705
00:42:31,500 --> 00:42:34,320
பட்டியல் நடுத்தர பார்த்துக்கொண்டே.

706
00:42:34,320 --> 00:42:38,000
நாங்கள் நடுத்தர வயதில் தேடும் காரணம் மற்றும், நாம் பட்டியலை வரிசையாக்கம் என்று தேவைப்படும்

707
00:42:38,000 --> 00:42:40,580
அல்லது வேறு நடுத்தர எங்கே என்று எங்களுக்கு தெரியாது, நாங்கள் பார்த்து வேண்டும்

708
00:42:40,580 --> 00:42:44,480
அதை கண்டுபிடிக்க முழு பட்டியல், பின்னர் அந்த இடத்தில் நாம் நேரத்தை வீணடிக்காதீர்கள்.

709
00:42:44,480 --> 00:42:48,480
நாம் ஒரு வரிசைப்படுத்தப்பட்ட பட்டியலை நாம் நடுத்தர கண்டறிய என்றால், நாம் நடுத்தர ஒப்பிட்டு போகிறோம்

710
00:42:48,480 --> 00:42:51,590
உறுப்பு நாம் தேடும்.

711
00:42:51,590 --> 00:42:54,640
அது மிக அதிகமாக இருந்தால், நாம் சரி பாதி மறக்க முடியாது

712
00:42:54,640 --> 00:42:57,810
எங்களுக்கு தெரியும், ஏனெனில் அது நமது உறுப்பு ஏற்கனவே அதிகமாக இருந்தால்

713
00:42:57,810 --> 00:43:01,080
இந்த உறுப்பு வலது எல்லாம் கூட அதிகம்,

714
00:43:01,080 --> 00:43:02,760
நாம் இனி அங்கு பார்க்க தேவையில்லை.

715
00:43:02,760 --> 00:43:05,430
எங்கே மறுபுறம், நமது உறுப்பு மிகவும் குறைவாக இருந்தால்,

716
00:43:05,430 --> 00:43:08,700
நாம், அந்த உறுப்பு இடது எல்லாம் கூட மிக குறைந்த என்று

717
00:43:08,700 --> 00:43:11,390
அது உண்மையில் ஒன்று, அங்கு பார்க்க பயன் இல்லை.

718
00:43:11,390 --> 00:43:15,760
இந்த வழியில், பட்டியல் இடையில் உள்ள ஒவ்வொரு அடியிலும் நாம் இருக்கும் ஒவ்வொரு நேரத்தில்,

719
00:43:15,760 --> 00:43:19,060
திடீரென்று எங்களுக்கு தெரியும், ஏனெனில் நாங்கள் அரை எமது பிரச்சினையை குறைக்க போகிறோம்

720
00:43:19,060 --> 00:43:23,040
நாம் தேடும் ஒரு இருக்க முடியாது என்று எண்கள் ஒரு மொத்தமாக.

721
00:43:23,040 --> 00:43:26,950
>> சூடோகுறியீடு இந்த, இந்த மாதிரி ஏதாவது இருக்கும் என்று

722
00:43:26,950 --> 00:43:30,990
ஏனெனில் நாங்கள், அரை ஒவ்வொரு முறை பட்டியல் குறைத்து

723
00:43:30,990 --> 00:43:34,920
மடக்கை என்று நேர்கோட்டு நம் மோசமான ரன் நேரம் தாவல்கள்.

724
00:43:34,920 --> 00:43:39,260
திடீரென்று நாம் உள்நுழைவு பட்டியலில் ஒரு உறுப்பு கண்டறிய நடவடிக்கை.

725
00:43:39,260 --> 00:43:42,460
சிறந்த வழக்கு இயங்கும் நேரம், எனினும், இன்னும் மாறிலி

726
00:43:42,460 --> 00:43:45,180
இப்போது ஏனெனில், நாங்கள் தேடும் உறுப்பு என்று நாம்

727
00:43:45,180 --> 00:43:48,380
அசல் பட்டியலை எப்போதும் சரியான நடுத்தர.

728
00:43:48,380 --> 00:43:52,080
எனவே, நாம் வேண்டும் என பெரிய நம் பட்டியலில் வளர முடியும், ஆனால் நாம் தேடும் உறுப்பு நடுத்தர உள்ளது என்றால்

729
00:43:52,080 --> 00:43:54,910
அது தான் எங்களுக்கு 1 நடவடிக்கை எடுக்க நடக்கிறது.

730
00:43:54,910 --> 00:44:00,920
நாம் O (log n) மற்றும் Ω (1) அல்லது நிலையான தான் அதனால் தான்.

731
00:44:00,920 --> 00:44:04,510
அது உண்மையில் இந்த பட்டியலில் இரும தேடல் ஓடிப்போகட்டும்.

732
00:44:04,510 --> 00:44:08,020
எனவே நாம் உறுப்பு 164 தேடும் சொல்கிறேன்.

733
00:44:08,020 --> 00:44:11,650
நாம் என்ன செய்ய போகிறாய் முதல் விஷயம் இந்த பட்டியலில் இடையில் கண்டறிய வேண்டும்.

734
00:44:11,650 --> 00:44:15,060
அது மிக, இடையில் இந்த 2 எண்கள் இடையில் விழும் என்று நடக்கும்

735
00:44:15,060 --> 00:44:18,960
எனவே, இடையில் 2 எண்கள் இடையே விழும் ஒவ்வொரு முறையும், நான் தன்னிச்சையாக என்று நாம்

736
00:44:18,960 --> 00:44:21,150
அது தான் சுற்றி பார்க்க.

737
00:44:21,150 --> 00:44:24,330
நாங்கள் இந்த ஒவ்வொரு அடியிலும் செய்ய உறுதி செய்ய வேண்டும்.

738
00:44:24,330 --> 00:44:29,040
எனவே நாம் சுற்றிலும் போகிறோம், நாம் 161 எங்கள் பட்டியலில் நடுத்தர என்று போகிறோம்.

739
00:44:29,040 --> 00:44:34,640
அதனால் 161 <164, மற்றும் 161 இடது ஒவ்வொரு உறுப்பு

740
00:44:34,640 --> 00:44:39,120
மேலும் <164, எனவே நாம் அது எங்களுக்கு உதவ போவதில்லை என்று எனக்கு தெரியும்

741
00:44:39,120 --> 00:44:42,690
நாங்கள் அங்கு இருக்க முடியாது தேடும் உறுப்பு ஏனெனில் இங்கு தேட ஆரம்பிக்க.

742
00:44:42,690 --> 00:44:47,060
எனவே நாம் என்ன செய்யலாம், நாம் தான் பட்டியல் ஒட்டுமொத்த இடது அரை மறக்க முடியாது

743
00:44:47,060 --> 00:44:51,700
இப்போது மட்டும் 161 முதல் உரிமை இருந்து கருதுகின்றனர்.

744
00:44:51,700 --> 00:44:54,050
>> எனவே மீண்டும், இந்த இடையில் உள்ளது; அது தான் சுற்றி பார்க்க.

745
00:44:54,050 --> 00:44:56,260
இப்போது 175 மிகவும் பெரியதாக உள்ளது.

746
00:44:56,260 --> 00:44:59,180
நாம் அது, எங்களுக்கு இங்கே அல்லது இங்கே பார்க்க உதவ போவதில்லை என்று தெரியும்

747
00:44:59,180 --> 00:45:06,610
எனவே நாம் அந்த எறியுங்கள் முடியாது, இறுதியில் நாம் 164 அடித்து விடுவேன்.

748
00:45:06,610 --> 00:45:10,560
இரும தேடல் எந்த கேள்விகள்?

749
00:45:10,560 --> 00:45:14,180
நாம் ஏற்கெனவே வரிசையில் பட்டியல் மூலம் தேடி இருந்து நகர்த்த

750
00:45:14,180 --> 00:45:17,660
உண்மையில் எந்த வரிசையில் எண்கள் பட்டியல் எடுத்து

751
00:45:17,660 --> 00:45:20,960
மற்றும் ஏறுவரிசையில் அந்த பட்டியலில் உள்ளது.

752
00:45:20,960 --> 00:45:24,060
நாம் பார்த்து முதல் வழிமுறை குமிழி வரிசையாக்கம் அழைக்கப்பட்டது.

753
00:45:24,060 --> 00:45:27,300
இந்த நாங்கள் பார்த்தோம் வழிமுறைகளும் எளிய இருக்கும்.

754
00:45:27,300 --> 00:45:32,970
குமிழி வரிசையாக்கம், பட்டியல் உள்ளே எந்த 2 உறுப்புகள் இடத்தில் வெளியே இருக்கும் போது கூறுகிறார்

755
00:45:32,970 --> 00:45:36,500
அதிக எண்ணிக்கையில் குறைந்த எண்ணிக்கையிலான இடது உள்ளது அதாவது,

756
00:45:36,500 --> 00:45:40,190
அந்த பட்டியலில் இருக்கும் என்று பொருள், ஏனெனில் நாம், அவர்களை மாற்ற போகிறோம்

757
00:45:40,190 --> 00:45:42,860
அதற்கு முன் விட "இன்னும் வரிசைப்படுத்தப்பட்ட".

758
00:45:42,860 --> 00:45:45,180
மற்றும் நாம் மீண்டும் மீண்டும் மீண்டும் இந்த செயற்பாட்டை தொடர போகிறேன்

759
00:45:45,180 --> 00:45:52,100
இறுதியில் கூறுகள் அவற்றின் சரியான இடத்தில் குமிழி வகை மற்றும் நாம் ஒரு வரிசைப்படுத்தப்பட்ட பட்டியலை வரை.

760
00:45:52,100 --> 00:45:57,230
>> இந்த ரன் நேரம் ஓ போகிறது (n ²). ஏன்?

761
00:45:57,230 --> 00:46:00,370
நன்றாக, மிக மோசமான நிலையில் இருப்பதால், நாம் ஒவ்வொரு உறுப்பு எடுத்து சென்று, மற்றும்

762
00:46:00,370 --> 00:46:04,570
நாம் பட்டியலில் ஒவ்வொரு மற்ற உறுப்பு அதை ஒப்பிட்டு முடிவுக்கு போகிறோம்.

763
00:46:04,570 --> 00:46:08,030
ஆனால் சிறந்த வழக்கில், நாம் ஏற்கனவே வரிசையாக்கம் பட்டியலில் உள்ளது, குமிழி வரிசையாக்கம் தான்

764
00:46:08,030 --> 00:46:12,230
ஒருமுறை செல்ல, சொல்ல போகிறேன் "இல்லை. நான் எந்த பரிமாற்றங்கள் செய்யவில்லை, எனவே நான் செய்து வருகிறேன்."

765
00:46:12,230 --> 00:46:17,410
நாம் Ω (n) ஒரு சிறந்த வழக்கு இயங்கும் நேரம்.

766
00:46:17,410 --> 00:46:20,680
ஒரு பட்டியலில் குமிழி வரிசையாக்கம் ஓடிப்போகட்டும்.

767
00:46:20,680 --> 00:46:23,560
அல்லது முதல், அது தான் மிகவும் விரைவாக சில சூடோகுறியீடு பார்க்க வேண்டும்.

768
00:46:23,560 --> 00:46:28,160
நாம், நாம் வளைய ஒவ்வொரு மீள்செய்கையில், கண்காணிப்பதற்கான வேண்டும் என்று விரும்புகிறேன்

769
00:46:28,160 --> 00:46:32,190
நாம் எந்த உறுப்புகளை மாற்றம் அல்லது பின்தொடருங்கள்.

770
00:46:32,190 --> 00:46:37,610
என்று காரணம் எனவே, நாம் எந்த உறுப்புகளை பரிமாற்றம் இல்லை போது நிறுத்த போகிறோம்.

771
00:46:37,610 --> 00:46:41,980
எனவே எங்கள் வளைய ஆரம்பத்தில் நாம் எதையும் பரிமாற்றம் இல்லை, நாம் தவறு என்று நான் கூறுவேன்.

772
00:46:41,980 --> 00:46:47,170
இப்போது, நாம் பட்டியல் மூலம் சென்று நான் உறுப்பு நான் + 1 உறுப்பு ஒப்பிட்டு போகிறோம்

773
00:46:47,170 --> 00:46:50,310
அது ஒரு பெரிய எண்ணிக்கையிலான ஒரு சிறிய எண்ணிக்கையிலான இடது உள்ளது என்று வழக்கு என்றால்,

774
00:46:50,310 --> 00:46:52,310
நாம் தான் அவர்களை மாற்ற போகிறோம்.

775
00:46:52,310 --> 00:46:54,490
>> பின்னர் நாம் ஒரு உறுப்பு மாற்றப்பட்டது என்பதை நினைவில் போகிறோம்.

776
00:46:54,490 --> 00:46:58,900
என்று நாம் பட்டியல் மூலம் குறைந்தபட்சம் 1 முறை செல்ல வேண்டும் என்று அர்த்தம்

777
00:46:58,900 --> 00:47:02,160
முழு பட்டியல் ஏற்கனவே வரிசையாக்கம் போது நாம் நிறுத்தி இதில் நிலையில் இருப்பதால்,

778
00:47:02,160 --> 00:47:04,890
நாம் எந்த பரிமாற்றங்கள் செய்யவில்லை என்று அர்த்தம்.

779
00:47:04,890 --> 00:47:09,960
எங்கள் நிலை இங்கு உள்ளது அதனால் தான் 'சில கூறுகளை பரிமாற்றம் செய்யப்பட்டுள்ளது போது.'

780
00:47:09,960 --> 00:47:13,720
எனவே இப்போது இந்த பட்டியலில் இயங்கும் பார்க்க வேண்டும்.

781
00:47:13,720 --> 00:47:16,640
நான் பட்டியல் 5,0,1,6,4 வேண்டும்.

782
00:47:16,640 --> 00:47:19,850
குமிழி வரிசையாக்கம் இடது அனைத்து வழி தொடங்க போகிறது, மற்றும் அதை ஒப்பிட்டு நடக்கிறது

783
00:47:19,850 --> 00:47:24,700
நான் உறுப்புகள், மிகவும் உறுப்பு 1 இது 0 என நான் + 1.

784
00:47:24,700 --> 00:47:29,020
, இது, நன்றாக 5> 0 என்று நடக்கிறது, ஆனால் இப்போது 5 இடது உள்ளது

785
00:47:29,020 --> 00:47:32,500
நான் 5 மற்றும் 0 இடமாற்றம் செய்ய வேண்டும்.

786
00:47:32,500 --> 00:47:35,470
நான் அவர்களை இடமாற்றம் போது, திடீரென்று நான் இந்த வேறுபட்ட பட்டியலை பெற.

787
00:47:35,470 --> 00:47:38,260
இப்போது 5> 1, நாம் அவர்களை மாற்ற போகிறோம்.

788
00:47:38,260 --> 00:47:42,160
5> 6 அல்ல, நாங்கள் இங்கே ஒன்றும் செய்ய தேவையில்லை.

789
00:47:42,160 --> 00:47:46,690
ஆனால் 6> 4, நாம் மாற்ற வேண்டும்.

790
00:47:46,690 --> 00:47:49,740
மீண்டும், நாம் இறுதியில் கண்டறிய முழு பட்டியல் மூலம் இயக்க வேண்டும்

791
00:47:49,740 --> 00:47:52,330
இந்த வரிசையில் வெளியே என்று; நாம் அவர்களை இடமாற்றம்,

792
00:47:52,330 --> 00:47:57,120
இந்த இடத்தில் நாம் பட்டியல் மூலம் 1 முறை இயக்க வேண்டும்

793
00:47:57,120 --> 00:48:05,390
எல்லாம் அதன் பொருட்டு தான், இந்த புள்ளி குமிழி வரிசையாக்கம் மணிக்கு முடிந்தது என்று உறுதிப்படுத்தி கொள்ள.

794
00:48:05,390 --> 00:48:10,720
சில கூறுகளை எடுத்து, அவற்றை வரிசைப்படுத்த ஒரு வேறுபட்ட வழிமுறை தேர்வு மாதிரியான.

795
00:48:10,720 --> 00:48:15,740
தேர்வு வகையான பின்னால் கருத்தை நாம் பட்டியலில் ஒரு வரிசைப்படுத்தப்பட்ட பகுதியை உருவாக்க போகிறோம் என்று

796
00:48:15,740 --> 00:48:18,150
ஒரு நேரத்தில் 1 உறுப்பு.

797
00:48:18,150 --> 00:48:23,170
>> மற்றும் நாம் அதை செய்ய போகிறோம் வழி பட்டியல் இடது பிரிவில் கட்டமைப்பில் உள்ளது.

798
00:48:23,170 --> 00:48:27,510
மற்றும் அடிப்படையில், ஒவ்வொரு - ஒவ்வொரு அடியிலும், நாம் விட்டு சிறிய உறுப்பு போகிறாய்

799
00:48:27,510 --> 00:48:32,310
இன்னும் வரிசையில், நாம் அந்த வரிசையில் பிரிவில் நகர்த்த போகிறீர்கள்.

800
00:48:32,310 --> 00:48:35,850
அதாவது நாம் தொடர்ந்து குறைந்த வரிசையாக்கம் செய்யப்படாத உறுப்பு கண்டுபிடிக்க வேண்டும்

801
00:48:35,850 --> 00:48:40,720
பின்னர் அந்த குறைந்தபட்ச உறுப்பு எடுத்து அதை அதை இடமாற்றம்

802
00:48:40,720 --> 00:48:45,090
விட்டு மிக உறுப்பு சரியாகவில்லை என்று.

803
00:48:45,090 --> 00:48:50,890
இந்த இயக்க நேரம் ஓ போகிறது (n ²) ஏனெனில் மோசமான நிலையில்

804
00:48:50,890 --> 00:48:55,070
நாம் ஒவ்வொரு மற்ற உறுப்பு ஒவ்வொரு உறுப்பு ஒப்பிட்டு பார்க்க வேண்டும்.

805
00:48:55,070 --> 00:48:59,250
நாம் பட்டியல் இடது அரை மணிக்கு ஆரம்பித்தால், நாம் வேண்டும் என்று காரணம்

806
00:48:59,250 --> 00:49:02,970
சிறிய உறுப்பு கண்டுபிடிக்க முழு உரிமை பிரிவு வழியாக செல்ல.

807
00:49:02,970 --> 00:49:05,430
பின்னர், மீண்டும், நாம் முழு உரிமை பிரிவில் மீது போய் வேண்டும்

808
00:49:05,430 --> 00:49:08,210
மீண்டும் மேல் மேல் மேல் மேல் போகும்.

809
00:49:08,210 --> 00:49:11,350
என்று n ² இருக்க போகிறது. நாம் வளைய மற்றொரு நெளிவு உள்ளே ஒரு தேவை போகிறாய்

810
00:49:11,350 --> 00:49:13,350
இதில் n ² தெரிவிக்கிறது.

811
00:49:13,350 --> 00:49:16,530
சிறந்த வழக்கு சிந்தனையில், நாம் அதை ஏற்கனவே வரிசைப்படுத்தப்பட்ட பட்டியலை கொடுக்க சொல்கிறேன்;

812
00:49:16,530 --> 00:49:19,270
நாம் உண்மையில் n ² விட நல்ல செய்ய வேண்டாம்.

813
00:49:19,270 --> 00:49:21,730
தேர்வு வகையான என்று தெரிந்தும் இல்லை, ஏனெனில்

814
00:49:21,730 --> 00:49:25,540
குறைந்தபட்ச உறுப்பு தான் நான் பார்க்க வேண்டும் நடக்க உள்ளது.

815
00:49:25,540 --> 00:49:28,970
அது இன்னும் இந்த உண்மையில் குறைந்தபட்ச என்று உறுதிப்படுத்தி கொள்ள வேண்டும்.

816
00:49:28,970 --> 00:49:31,670
>> இந்த வழிமுறையை பயன்படுத்தி, அதை குறைந்தபட்ச என்று உறுதிப்படுத்தி கொள்ள ஒரே வழி,

817
00:49:31,670 --> 00:49:34,640
மீண்டும் ஒவ்வொரு உறுப்பு பார்க்க வேண்டும்.

818
00:49:34,640 --> 00:49:38,420
எனவே உண்மையில், நீங்கள் அதை கொடுத்தால் - நீங்கள் தேர்வு வகையான ஏற்கனவே வரிசையாக்கம் பட்டியல் கொடுத்தால்,

819
00:49:38,420 --> 00:49:42,720
அது இன்னும் சரியாகவில்லை என்று ஒரு பட்டியலை கொடுத்து விட நல்ல செய்ய போவதில்லை.

820
00:49:42,720 --> 00:49:46,320
இது வழக்கில் இருக்கும் நடந்தால் மூலம், ஏதாவது ஓ (ஒன்று) என்று

821
00:49:46,320 --> 00:49:50,640
ஏதோ ஒமேகா, நாம் மட்டும் இன்னும் கினார் அது ஏதாவது θ என்று சொல்ல முடியாது.

822
00:49:50,640 --> 00:49:52,760
நீங்கள் தான் என்று தான் அர்த்தம் என்ன என்று, எங்கு வந்து பார்க்க நீங்கள்.

823
00:49:52,760 --> 00:49:57,580
>> ஏதாவது n, தீட்டா இருந்தால் ², அது இரு பெரிய ஓ (n ²) மற்றும் Ω (n ²) ஆகும்.

824
00:49:57,580 --> 00:49:59,790
சிறந்த நிலை மற்றும் மோசமான நிலை எனவே, இது, ஒரு வித்தியாசமும் இல்லை

825
00:49:59,790 --> 00:50:04,400
படிமுறை தான் ஒவ்வொரு முறையும் செய்ய போகிறாள்.

826
00:50:04,400 --> 00:50:06,610
இந்த தேர்வை நடத்த வேண்டும் சூடோகுறியீடு இருக்க முடியும் என்று.

827
00:50:06,610 --> 00:50:10,630
நாம் அடிப்படையில் நான் பட்டியல் மீது மீண்டும் கூறு வேண்டும் என்று போகிறீர்கள்

828
00:50:10,630 --> 00:50:15,180
வலது, மற்றும் சுழற்சி ஒவ்வொரு மறு செய்கை இடது இருந்து, நான் நகர்த்த போகிறேன்

829
00:50:15,180 --> 00:50:19,780
பட்டியலில் இந்த வரிசையில் பகுதியை நோக்கி குறைந்தபட்ச உறுப்பு.

830
00:50:19,780 --> 00:50:23,260
ஒருமுறை நான் அங்கு ஏதாவது நகர, நான் மீண்டும் அந்த உறுப்பு பார்க்க வேண்டும்.

831
00:50:23,260 --> 00:50:28,600
விரைவில் நான் பட்டியல் இடது பிரிவில் உள்ள ஒரு உறுப்பு இடமாற்றம், அது வரிசைப்படுத்தப்பட்ட ஏனென்றால்

832
00:50:28,600 --> 00:50:32,600
நாம் குறைவாக பயன்படுத்தி ஏறுவரிசையில் எல்லாம் செய்கிறாய் ஏனெனில்.

833
00:50:32,600 --> 00:50:38,740
எனவே, சரியா, நாம் நிலையை நான் இருக்கும்போது, நாம் உள்ள உறுப்புகள் அனைத்தும் இருக்க வேண்டும், என்றார்

834
00:50:38,740 --> 00:50:42,260
குறைந்தபட்ச கண்டுபிடிக்க பொருட்டு நான் வலது.

835
00:50:42,260 --> 00:50:46,150
அதனால் நாம் பட்டியலை இறுதி வரை நான் + 1 இருந்து பார்க்க வேண்டும் என்பதாகும்.

836
00:50:46,150 --> 00:50:51,610
இப்போது, நாம் தற்போது தேடும் உறுப்பு, இதுவரை நம் குறைந்தபட்ச விட குறைவாக இருந்தால்

837
00:50:51,610 --> 00:50:54,190
நினைவி, நாம் தான் இருக்கும் குறைந்தபட்ச துவங்கும் இது,

838
00:50:54,190 --> 00:50:57,020
என்ன உறுப்பு நாம் தற்போது இருக்கிறோம்; நான் குறைந்தபட்ச என்று கொள்வோம்.

839
00:50:57,020 --> 00:51:00,270
நான் விட சிறிய என்று ஒரு உறுப்பு இருந்தால், நான், சரி, நான் போகிறேன்

840
00:51:00,270 --> 00:51:02,700
நன்றாக, நான் ஒரு புதிய குறைந்தபட்ச கிடைத்தது.

841
00:51:02,700 --> 00:51:06,080
நான் அந்த குறைந்தபட்ச அங்கு நினைவில் போகிறேன்.

842
00:51:06,080 --> 00:51:09,560
>> அதனால் இப்போது, ஒரு முறை நான், அந்த உரிமை வரிசையாக்கம் செய்யப்படாத பிரிவில் வழியாக சென்று

843
00:51:09,560 --> 00:51:16,690
நான் நிலையில் நான் இல்லை என்று உறுப்பு கொண்ட குறைந்தபட்ச உறுப்பு இடமாற்றம் போகிறேன் கூற முடியும்.

844
00:51:16,690 --> 00:51:21,100
என்று என் பட்டியலை கட்டமைக்க நடக்கிறது, இடது இருந்து வலது பட்டியலில் என் வரிசைப்படுத்தப்பட்ட பகுதி,

845
00:51:21,100 --> 00:51:25,190
நாம் எப்போதும் அந்த பகுதியில் தான் மீண்டும் ஒரு உறுப்பு பார்க்க தேவையில்லை.

846
00:51:25,190 --> 00:51:27,930
நாம் அது மாற்றப்பட்டது.

847
00:51:27,930 --> 00:51:30,260
எனவே இந்த பட்டியலில் தேர்வு வகையான இயக்க அனுமதிக்க.

848
00:51:30,260 --> 00:51:38,220
இங்கே நீல உறுப்பு நான் போகிறது, மற்றும் சிவப்பு உறுப்பு குறைந்தபட்ச உறுப்பு போகிறது.

849
00:51:38,220 --> 00:51:41,570
அதனால் நான் 5 மணிக்கு எனவே, பட்டியல் இடது அனைத்து வழி தொடங்குகிறது.

850
00:51:41,570 --> 00:51:44,610
இப்போது நாம் குறைந்தபட்ச வரிசையாக்கம் செய்யப்படாத உறுப்பு கண்டுபிடிக்க வேண்டும்.

851
00:51:44,610 --> 00:51:49,480
எனவே 0 <5, அதனால் 0 என் புதிய குறைந்தபட்ச என்று.

852
00:51:49,480 --> 00:51:53,820
>> நாம், 0 மிகச்சிறிய என்று அடையாளம் காண முடியும் என்றாலும், ஏனெனில் ஆனால் நான், அங்கு நிறுத்த முடியாது

853
00:51:53,820 --> 00:51:59,390
நாம் உறுதி செய்ய பட்டியலை ஒவ்வொரு மற்ற உறுப்பு வழியாக இயக்க வேண்டும்.

854
00:51:59,390 --> 00:52:01,760
, 6 பெரியது பெரியது 1 எனவே, 4 பெரியது.

855
00:52:01,760 --> 00:52:05,850
இந்த உறுப்புகள் அனைத்தும் பார்த்து, நான் 0 சிறியது தீர்மானித்துள்ளோம் என்று பொருள்.

856
00:52:05,850 --> 00:52:09,800
நான் 5 மற்றும் 0 இடமாற்றம் போகிறேன்.

857
00:52:09,800 --> 00:52:15,480
ஒருமுறை நான் அந்த இடமாற்ற, நான் ஒரு புதிய பட்டியலை பெற போகிறேன், நான் மீண்டும் அந்த 0 பார்க்க வேண்டும் என்று எனக்கு தெரியும்

858
00:52:15,480 --> 00:52:19,380
ஒருமுறை நான் மாற்றப்பட்டது ஏனென்றால், நான் அதை வகைப்படுத்த மற்றும் நாம் முடித்துவிட்டீர்கள்.

859
00:52:19,380 --> 00:52:22,730
இப்போது அது மிகவும், நீல உறுப்பு மீண்டும் 5 என்று நடக்கும்

860
00:52:22,730 --> 00:52:26,030
நாம் அது 1 தீர்மானிக்க, 1 பார்க்க 6 மற்றும் 4 வேண்டும்

861
00:52:26,030 --> 00:52:31,520
சிறிய குறைந்தபட்ச உறுப்பு உள்ளது, எனவே 1 மற்றும் 5 இடமாற்றம் கிடைக்கும்.

862
00:52:31,520 --> 00:52:36,890
மீண்டும், நாம் பார்க்க வேண்டும் - 6 மற்றும் 4 முதல் 5 ஒப்பிட்டு,

863
00:52:36,890 --> 00:52:39,830
நாம் 4 மற்றும் 5 இடமாற்றம் செய்ய, மற்றும் இறுதியாக, ஒப்பிட்டு

864
00:52:39,830 --> 00:52:45,740
அந்த 2 எண்கள் மற்றும் நாம் வரிசைப்படுத்தப்பட்ட பட்டியலை பெறும் வரை அவர்களுக்கு பரிமாறிக்கொள்ளலாம்.

865
00:52:45,740 --> 00:52:49,730
தேர்வு வகையான எந்த கேள்விகள்?

866
00:52:49,730 --> 00:52:56,420
சரி. அது இங்கே கடந்த இங்கு எழுதப்படும் கருத்துகள் செல்லலாம், அந்த மறுநிகழ்வு உள்ளது.

867
00:52:56,420 --> 00:52:59,810
>> மறுநிகழ்வு, ஞாபகமிருக்கட்டும், இது உண்மையில் மெட்டா விஷயம் ஒரு செயல்பாடு

868
00:52:59,810 --> 00:53:02,740
மீண்டும் மீண்டும் தன்னை அழைப்பு விடுத்துள்ளது.

869
00:53:02,740 --> 00:53:05,620
அதனால் சில புள்ளியில், நம் fuction மீண்டும் மீண்டும் தன்னை அழைத்து போது,

870
00:53:05,620 --> 00:53:10,100
நாம் அழைப்பு தடுக்க இது சில புள்ளி இருக்க வேண்டும்.

871
00:53:10,100 --> 00:53:13,670
நாங்கள் அதை செய்ய வில்லை என்றால், நாம் மட்டும் எப்போதும் இதை தொடர்ந்து எனென்றால்,

872
00:53:13,670 --> 00:53:16,660
எங்கள் திட்டம் தான் முறித்து கொள்ள போவதில்லை.

873
00:53:16,660 --> 00:53:19,200
இந்த நிலையில் நாம் அடிப்படை வழக்கு அழைப்பு.

874
00:53:19,200 --> 00:53:22,570
மற்றும் அடிப்படை வழக்கில், மாறாக மீண்டும் ஒரு விழா அழைப்பு விட, என்கிறார்

875
00:53:22,570 --> 00:53:25,330
நான் சில மதிப்பு திரும்பி போகிறேன்.

876
00:53:25,330 --> 00:53:28,080
நாம் ஒரு மதிப்பு வந்துள்ளேன் முறை, அதனால் நாம், நம்மை அழைத்து நிறுத்தி

877
00:53:28,080 --> 00:53:32,550
நாங்கள் இதுவரை செய்த அழைப்புகள் மீதி திரும்ப முடியும்.

878
00:53:32,550 --> 00:53:36,050
அடிப்படை வழக்கை எதிர் குவிப்பு வழக்கு.

879
00:53:36,050 --> 00:53:39,050
இந்த நாங்கள் உள்ளே தற்போது என்று செயல்பாடு மற்றொரு அழைப்பை வேண்டும் போது தான்

880
00:53:39,050 --> 00:53:44,690
நாம் ஒருவேளை, எப்போதும் எனினும், பல்வேறு விவாதங்களை பயன்படுத்த வேண்டும்.

881
00:53:44,690 --> 00:53:48,940
>> நாம் f என்று ஒரு செயல்பாடு, மற்றும் எஃப் மட்டும், 1 வாதத்தை எடுத்து என்று நீங்கள்

882
00:53:48,940 --> 00:53:52,010
நாம் வெறும் f (1), f (1), f (1) அழைப்பு வைக்க, அது தான் நடக்கிறது

883
00:53:52,010 --> 00:53:56,510
வாதம் 1 குவிப்பு வழக்கு விழுகிறது, நாம் இன்னும் நிறுத்த போவதில்லை.

884
00:53:56,510 --> 00:54:01,620
நாம் ஒரு தளத்தை வழக்கு வேண்டும் என்றால், நாம் இறுதியில் நாம் அடிப்படை வழக்கு அடிக்க போகிறோம் என்பதை உறுதி செய்ய வேண்டும்.

885
00:54:01,620 --> 00:54:04,250
நாம் இந்த சுழல்நிலை வழக்கு தங்கி வைக்க கூடாது.

886
00:54:04,250 --> 00:54:09,870
பொதுவாக, நாம் நம்மை அழைக்க போது, நாம் ஒருவேளை வேறு வாதம் ஒவ்வொரு நேரம் போகிறது.

887
00:54:09,870 --> 00:54:12,700
இங்கே ஒரு மிக எளிய சுழல்நிலை செயல்பாடு ஆகும்.

888
00:54:12,700 --> 00:54:15,090
இந்த பல காரணியாலான கணக்கிட வேண்டும்.

889
00:54:15,090 --> 00:54:17,790
மேலே நாம் நம் அடிப்படை வழக்கில் இல்லை இங்கே top.

890
00:54:17,790 --> 00:54:22,330
N ≤ 1, நாம் மீண்டும் காரணியாலான அழைக்க போவதில்லை என்று வழக்கு.

891
00:54:22,330 --> 00:54:26,490
நாம் நிறுத்த போகிறோம்; நாம் சில மதிப்பு திரும்ப போகிறோம்.

892
00:54:26,490 --> 00:54:30,170
இந்த உண்மை இல்லை என்றால், நாம் நம் குவிப்பு வழக்கு அடிக்க போகிறாய்.

893
00:54:30,170 --> 00:54:33,550
என்று மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் நாங்கள், காரணியாலான (n) அழைப்பு இல்லை என்று இங்கே கவனிக்க.

894
00:54:33,550 --> 00:54:36,810
நாம் வேறு ஏதாவது காரணியாலான அழைக்க போகிறோம்.

895
00:54:36,810 --> 00:54:40,850
>> மற்றும் நீ, நாம் ஒரு காரணியாலான (5) அல்லது ஏதாவது கடந்து இறுதியில் என்றால், பார்க்க முடியும்

896
00:54:40,850 --> 00:54:45,900
நாம் காரணியாலான (4) மற்றும் பல அழைக்க போகிறோம், இறுதியில் நாம் இந்த தளத்தை வழக்கு அடிக்க போகிறாய்.

897
00:54:45,900 --> 00:54:51,730
எனவே இந்த நல்ல தெரிகிறது. நாம் உண்மையில் இந்த ரன் போது என்ன நடக்கிறது என்று பார்ப்போம்.

898
00:54:51,730 --> 00:54:57,840
இந்த அடுக்கு, மற்றும் நாம் பிரதான வாதம் (4) இந்த செயல்பாடு அழைக்க போகிறார் என்று.

899
00:54:57,840 --> 00:55:02,200
எனவே ஒரு முறை காரணியாலான காண்கிறது மற்றும் = 4, காரணியாலான தன்னை அழைக்க வேண்டும்.

900
00:55:02,200 --> 00:55:05,010
இப்போது, திடீரென்று, நாம் (3) காரணியாலான வேண்டும்.

901
00:55:05,010 --> 00:55:10,780
எனவே இந்த செயல்பாடுகளை இறுதியில் நாம் நம் அடிப்படை வழக்கில் வெற்றி வரை வளர்ந்து கொண்டே போகிறது.

902
00:55:10,780 --> 00:55:17,830
இந்த கட்டத்தில், இந்த திரும்ப மதிப்பு திரும்ப (nx இந்த திரும்ப மதிப்பு), என்பது

903
00:55:17,830 --> 00:55:21,290
இந்த திரும்ப மதிப்பு இந்த nx திரும்ப மதிப்பு.

904
00:55:21,290 --> 00:55:23,290
இறுதியில் நாம் சில பல ஹிட் வேண்டும்.

905
00:55:23,290 --> 00:55:26,560
இங்கே மேலே, நாம் மீண்டும் 1 என்று.

906
00:55:26,560 --> 00:55:30,650
ஒரு முறை நாங்கள் அந்த எண்ணை திரும்ப அதாவது, நாம் ஸ்டேக் ஆஃப் இந்த பாப் முடியும்.

907
00:55:30,650 --> 00:55:36,570
இந்த காரணியாலான (1) செய்யப்படுகிறது.

908
00:55:36,570 --> 00:55:41,190
போது 1 வருமானம், இந்த காரணியாலான (1) வருமானம், 1 இந்த பதிலுக்கு.

909
00:55:41,190 --> 00:55:46,910
இந்த திரும்ப மதிப்பு, ஞாபகமிருக்கட்டும், இது திரும்ப மதிப்பு nx இருந்தது.

910
00:55:46,910 --> 00:55:50,720
திடீரென்று, இந்த பையன் நான் 2 திரும்ப வேண்டும் என்று தெரிகிறது.

911
00:55:50,720 --> 00:55:55,910
>> எனவே, நினைவில் இந்த மதிப்பை இங்கே திரும்பி மதிப்பு வெறும் nx உள்ளது திருப்பி.

912
00:55:55,910 --> 00:56:01,160
எனவே இப்போது நாம் 3 x 2 சொல்ல முடியாது, மற்றும் இறுதியாக, இங்கே நாம் கூற முடியும்

913
00:56:01,160 --> 00:56:04,010
இந்த 4 x 3 x 2 போகிறது.

914
00:56:04,010 --> 00:56:09,570
இந்த வருமானத்தை முறை, நாங்கள் பிரதான ஒரு முழு உள்ளே இறங்கி.

915
00:56:09,570 --> 00:56:15,460
மறுநிகழ்வு எந்த கேள்விகள்?

916
00:56:15,460 --> 00:56:17,090
எல்லாம் சரி. எனவே கேள்விகள் அதிக நேரம், இறுதியில் அங்கு

917
00:56:17,090 --> 00:56:23,360
ஆனால் இப்போது ஜோசப் மீதமுள்ள தலைப்புகள் மறைக்கும்.

918
00:56:23,360 --> 00:56:25,590
>> [ஜோசப் ஆங்] சரி. எனவே இப்போது நாம் recursions பற்றி பேசிவிட்டேன் என்று,

919
00:56:25,590 --> 00:56:27,840
அது மாதிரியான ஒன்றாக்க பற்றி கொஞ்சம் பேச வேண்டும்.

920
00:56:27,840 --> 00:56:31,740
ஒன்றாக்க வகையான அடிப்படையில் எண்கள் பட்டியல் வரிசையாக்க மற்றொரு வழி.

921
00:56:31,740 --> 00:56:36,430
அது ஒன்றிணைப்பு வகையான உடன், அது எவ்வாறு நீங்கள் ஒரு பட்டியல் உள்ளது, மற்றும் நாம் என்ன ஆகும்

922
00:56:36,430 --> 00:56:39,120
நாம் 2 பகுதிகளாக இந்த பிரித்து சொல்கிறார்கள்.

923
00:56:39,120 --> 00:56:42,750
நாம் முதலில், இடது பாதி மீண்டும் சேர்ப்பு வரிசையாக்கம் இயக்க வேண்டும்

924
00:56:42,750 --> 00:56:45,040
நாம், வலது பாதி மீது ஒருவித ஒன்றாக்க இயக்க வேண்டும்

925
00:56:45,040 --> 00:56:50,240
என்று இப்போது நாம் வரிசைப்படுத்தப்பட்ட என்று 2 பாதிகளுக்கு கொடுக்கிறது, மற்றும் இப்போது நாம் அந்த பாதிகளுக்கு இணைக்க போகிறோம்.

926
00:56:50,240 --> 00:56:55,010
இது ஒரு உதாரணம் இல்லாமல் பார்க்க ஒரு பிட் கடினமாக உள்ளது, எனவே இயக்கங்கள் மூலம் சென்று என்ன நடக்கிறது என்று பார்க்கலாம்.

927
00:56:55,010 --> 00:56:59,590
எனவே இந்த பட்டியல், நாங்கள் 2 பகுதிகளாக அதை பிரித்து தொடங்கும்.

928
00:56:59,590 --> 00:57:02,300
நாம் முதல் இடது பாதி மீது ஒருவித ஒன்றாக்க ரன்.

929
00:57:02,300 --> 00:57:06,660
அதனால் இடது பாதி தான், இப்போது நாம் மீண்டும் இந்த பட்டியல் மூலம் அவற்றை இயக்க

930
00:57:06,660 --> 00:57:09,800
இதில் நாம், மீண்டும், ஆனால் பின்னர் ஒன்றிணைப்பு வகையான கடந்து, மற்றும்

931
00:57:09,800 --> 00:57:13,270
இந்த பட்டியல் இடது புறம் நாம் அது மாதிரியான ஒன்றாக்க ரன்.

932
00:57:13,270 --> 00:57:15,880
இப்போது, நாம், 2 எண்கள் பட்டியல் கீழே கிடைக்கும்

933
00:57:15,880 --> 00:57:19,010
இப்போது இடது பாதி மட்டுமே 1 உறுப்பு நீளமாக உள்ளது, மற்றும் நாம் செய்ய முடியாது

934
00:57:19,010 --> 00:57:23,380
பாதியில் மட்டும் 1 உறுப்பு என்று ஒரு பட்டியலை பிரித்து, நாம் ஒரு முறை நாங்கள் 50 வேண்டும், என்று,

935
00:57:23,380 --> 00:57:26,400
இது வெறும் 1 உறுப்பு உள்ளது, இது ஏற்கனவே வரிசையாக்கம்.

936
00:57:26,400 --> 00:57:29,860
>> நாம் என்று முடித்துவிட்டீர்கள் முறை, நாம் என்று நாம் பார்க்க முடியும்

937
00:57:29,860 --> 00:57:32,230
இந்த பட்டியல் சரி பாதி செல்ல,

938
00:57:32,230 --> 00:57:36,480
மற்றும் 3 மேலும் அதனால் இப்போது இந்த பட்டியலில் இரண்டு பகுதிகளாக பிரிக்கப்பட்டு என்று வரிசைப்படுத்தப்பட்ட, மற்றும்

939
00:57:36,480 --> 00:57:39,080
நாம் மீண்டும் ஒன்றாக இந்த எண்கள் சேர முடியும்.

940
00:57:39,080 --> 00:57:45,320
எனவே 50 மற்றும் 3 பார்; 3 50 விட, அது முதல் சென்று பின்னர் 50 உள்ளே வருகிறது

941
00:57:45,320 --> 00:57:49,340
இப்போது, அந்த முடிந்தது; அதை சரி பாதி என்று பட்டியல் மற்றும் வகையான வரை சென்று.

942
00:57:49,340 --> 00:57:52,440
42 அது சொந்த எண், எனவே அது ஏற்கனவே வரிசையாக்கம் தான்.

943
00:57:52,440 --> 00:57:57,850
எனவே இப்போது நாம், முதல் போட்டு விடும் என்று, 2 மற்றும் 3 42 விட இந்த ஒப்பிட்டு

944
00:57:57,850 --> 00:58:02,340
இப்போது 42 போட்டு, மற்றும் 50 உள்ளே போட விடும்

945
00:58:02,340 --> 00:58:07,220
இப்போது, வரிசைப்படுத்தப்பட்ட என்று, நாம், மேலே மீண்டும் 1337 மற்றும் 15 அனைத்து வழியிலும் செல்கின்றன.

946
00:58:07,220 --> 00:58:14,560
சரி, நாம் இப்போது இந்த பட்டியலில் இடது பாதி பார்; 1337 தன்னை மூலம் அது 15 உடன் வரிசையாக்கம் மற்றும் அதே தான்.

947
00:58:14,560 --> 00:58:19,020
எனவே இப்போது நாம் அந்த அசல் பட்டியலில், 15 <1337, வரிசைப்படுத்த இந்த 2 எண்கள் இணைக்க

948
00:58:19,020 --> 00:58:23,060
அது முதல் சென்று, பின்னர் 1337 உள்ளே சென்று

949
00:58:23,060 --> 00:58:26,640
இப்போது நாம் மேலே அசல் பட்டியலில் இரண்டு பகுதிகளாக பிரிக்கப்பட்டுள்ளது.

950
00:58:26,640 --> 00:58:30,440
நாம் செய்ய வேண்டியதெல்லாம் இந்த இணைக்க வேண்டும்.

951
00:58:30,440 --> 00:58:36,890
இந்த பட்டியலில் முதல் 2 எண்கள், 3 <15 பாருங்கள், அது முதல் வரிசை வரிசையாக செல்கிறது.

952
00:58:36,890 --> 00:58:44,460
15 <42, எனவே, இப்போது உள்ளே சென்று 42 <1337, என்று உள்ளே சென்று

953
00:58:44,460 --> 00:58:51,010
50 <1337, அதனால் உள்ளே சென்று நாங்கள் இந்த பட்டியலில் 2 எண்கள் கழற்றி அறிகிறோம்.

954
00:58:51,010 --> 00:58:53,640
எனவே வெறும் 2 பட்டியல்கள் இடையே மாற்று.

955
00:58:53,640 --> 00:58:56,050
நாங்கள் தான் தொடக்கத்தில் தேடும், மற்றும் நாம் உறுப்பு பேசிக்கொண்டு

956
00:58:56,050 --> 00:59:00,270
அந்த சிறிய மற்றும் பிறகு எங்கள் அணி அதை வைத்து தான்.

957
00:59:00,270 --> 00:59:04,080
இப்போது நாம் அனைத்து பாதிகளுக்கு இணைக்கப்பட்டது நாங்கள் செய்து வருகிறோம்.

958
00:59:04,080 --> 00:59:07,780
>> பற்றி எந்த கேள்விகள் வகையான ஒன்றாக்க? ஆமாம்?

959
00:59:07,780 --> 00:59:14,190
[மாணவர்] அது வெவ்வேறு குழுக்களாக பிரித்து இருந்தால், ஏன் அவர்கள் ஒருமுறை அதை பிரித்து இல்லை

960
00:59:14,190 --> 00:59:19,970
நீங்கள் ஒரு குழுவில் 3 மற்றும் 2 வேண்டும்? [கேள்வி புரிந்து மற்ற]

961
00:59:19,970 --> 00:59:24,940
காரணம் - அந்த கேள்வி, நாம் அவர்களை பின் ஏன் நாம் தான் முதல் படி அவர்களை ஒன்றிணைக்க முடியாது?

962
00:59:24,940 --> 00:59:29,530
நாம் இதை செய்ய முடியும் காரணம், இருபுறமும் இடது பெரும்பாலான கூறுகள் துவங்க

963
00:59:29,530 --> 00:59:33,040
பின்னர், சிறிய ஒரு எடுத்து அதை வைத்து நாம் இந்த தெரியும் என்று

964
00:59:33,040 --> 00:59:35,290
தனிப்பட்ட பட்டியலை வரிசையாக்கம் கட்டளைகள் உள்ளன.

965
00:59:35,290 --> 00:59:37,290
நான் இரண்டு பகுதிகளாக இடது பெரும்பாலான கூறுகள் பார்த்துக்கொண்டிருக்கிறேன் இருந்தால்,

966
00:59:37,290 --> 00:59:40,490
நான் அவர்கள் அந்த பட்டியலை மிகச்சிறிய கூறுகள் இருக்க போகிறோம் என்று.

967
00:59:40,490 --> 00:59:43,930
அதனால் நான் இந்த பெரிய பட்டியலில் சிறிய உறுப்பு புள்ளிகள் அவற்றை முடியும்.

968
00:59:43,930 --> 00:59:47,810
மறுபுறம், நான் அங்கு இரண்டாம் நிலை அந்த 2 பட்டியலை பாருங்கள் என்றால்,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337, 15, அந்த சரியாகவில்லை.

970
00:59:51,640 --> 00:59:55,770
நான் 50 மற்றும் 1337 பாருங்கள் நீங்கள், நான் முதல் என் பட்டியலில் 50 வைக்க போகிறேன்.

971
00:59:55,770 --> 01:00:00,130
ஆனால் உண்மையில் 3 அந்த எல்லா வெளியே சிறிய உறுப்பு ஏனெனில், பயன் இல்லை.

972
01:00:00,130 --> 01:00:04,390
எனவே நாம் இந்த இணைந்த படி செய்ய மட்டுமே காரணம் எங்கள் பட்டியலில் ஏற்கனவே வரிசையாக்கம் ஏனெனில் இது.

973
01:00:04,390 --> 01:00:07,010
நாம் கீழே அனைத்து வழி இறங்க வேண்டும் ஏன் இது

974
01:00:07,010 --> 01:00:09,800
நாம் ஒரு ஒற்றை எண் போது, நீங்கள் ஒரு ஒற்றை எண் தெரியும் என்பதால்

975
01:00:09,800 --> 01:00:14,120
மற்றும் தன்னை ஏற்கனவே ஒரு வரிசைப்படுத்தப்பட்ட பட்டியல்.

976
01:00:14,120 --> 01:00:19,360
>> எந்த கேள்விகள்? இல்லை?

977
01:00:19,360 --> 01:00:24,260
Complexity? சரி, நீங்கள், ஒவ்வொரு படியிலும் இறுதியில் எண்கள் உள்ளது என்று பார்க்க முடியும்

978
01:00:24,260 --> 01:00:27,590
நாம், அரை பதிவு n முறை ஒரு பட்டியலை பிரித்து கொள்ளலாம்

979
01:00:27,590 --> 01:00:31,700
நாம் இந்த n x log N சிக்கலான இங்கு உள்ளது.

980
01:00:31,700 --> 01:00:34,940
நீங்கள் ஒன்றிணைப்பு வகையான சிறந்த வழக்கு n log n தான் பார்க்க வேண்டும், அது தான் நடக்கும்

981
01:00:34,940 --> 01:00:39,340
மோசமான, அல்லது அங்கு Ω, மேலும் n n log என்று.

982
01:00:39,340 --> 01:00:42,480
மனதில் கொள்ள வேண்டிய ஒன்று.

983
01:00:42,480 --> 01:00:45,750
செல்லும், அது சில சூப்பர் அடிப்படை கோப்பு நான் த / பெ மீது செல்லலாம்

984
01:00:45,750 --> 01:00:48,830
நீங்கள் ஏற பார்த்து இருந்தால், நாம் கணினி ஒருவித என்று கவனிக்க வேண்டும்

985
01:00:48,830 --> 01:00:51,270
நீங்கள் குறியீடு மூலம் படிக்க நீங்கள் ஒரு பதிவு கோப்பில் எழுத முடியும்.

986
01:00:51,270 --> 01:00:53,730
நீங்கள் அதை எப்படி என்று பார்ப்போம்.

987
01:00:53,730 --> 01:00:57,450
சரி, நாம் fprintf வேண்டும், நீங்கள், போலவே printf என்று முடியும்

988
01:00:57,450 --> 01:01:01,720
ஆனால் ஆரம்பம் இல் f எனவே அதற்கு பதிலாக ஒரு கோப்பு அச்சிடுகிறது, மற்றும்.

989
01:01:01,720 --> 01:01:07,570
இங்கு குறியீடு இந்த வகையான, நீங்கள் ஏற பார்க்க கூடும் என என்ன அது, இது,

990
01:01:07,570 --> 01:01:12,310
அது எண்கள் என்ன வரிசை மூலம் வரிசையில் உங்கள் 2 பரிமாண அணிகளில் அச்சிடுதல் மூலம் செல்கிறது.

991
01:01:12,310 --> 01:01:17,850
இந்த வழக்கில், printf உங்கள் முனையத்தில் அவுட் அச்சிடுகிறது அல்லது நாம் பிரிவின் நிலையான வெளியீடு அழைப்பு என்ன.

992
01:01:17,850 --> 01:01:22,170
>> இப்போது, இந்த வழக்கில், நாம் செய்ய வேண்டிய அனைத்து, fprintf உடன் printf பதிலாக உள்ளது

993
01:01:22,170 --> 01:01:26,770
நீங்கள் அச்சிட வேண்டும் என்ன கோப்பு அதை சொல்ல, இந்த வழக்கில் அது அந்த கோப்பு அது அவுட் அச்சிடுகிறது

994
01:01:26,770 --> 01:01:32,230
பதிலாக உங்கள் முனையத்தில் அதை அச்சிடுகிறது.

995
01:01:32,230 --> 01:01:36,500
நன்றாக, பின்னர் அந்த கேள்வியை கேட்கிறார்: எங்கே நாம் சரியான, கோப்பு இந்த வகையான கிடைக்கும்?

996
01:01:36,500 --> 01:01:39,840
நாம் இந்த fprintf fuction உள்நுழைய கடந்து ஆனால் நாம் அது எங்கிருந்து வந்தது தெரியாது.

997
01:01:39,840 --> 01:01:43,980
நன்றாக, ஆரம்ப குறியீடு உள்ள, நாம், இங்கு குறியீடு இந்த துண்டின் இருந்தது

998
01:01:43,980 --> 01:01:48,340
அடிப்படையில் திறந்த கோப்பு log.txt அழைப்பு என்று இது.

999
01:01:48,340 --> 01:01:53,220
என்று பின் நாம் என்ன செய்ய வேண்டும் நாம் கோப்பு உண்மையில் வெற்றிகரமாக திறக்கப்பட்டது என்று உறுதி செய்ய வேண்டும்.

1000
01:01:53,220 --> 01:01:57,070
அது பல காரணங்களுக்காக போகலாம்; நீங்கள் எடுத்துக்காட்டாக, உங்கள் கணினியில் போதுமான இடம் இல்லை.

1001
01:01:57,070 --> 01:01:59,790
நீங்கள் கோப்பு எந்த செயல்பாடுகளை செய்ய முன் அது எப்போதும் முக்கியம்

1002
01:01:59,790 --> 01:02:03,300
நாம் அந்த கோப்பு வெற்றிகரமாக திறக்கப்பட்டது என சோதிக்க வேண்டும்.

1003
01:02:03,300 --> 01:02:09,330
அதனால் என்ன ஒரு, என்று fopen ஒரு வாதம் என்று, நல்ல, நாம் பல வழிகளில் ஒரு கோப்பை திறக்க முடியாது.

1004
01:02:09,330 --> 01:02:13,510
நாம் தான் என்ன செய்ய முடியும், நாம், அது வெளியேறும் போது ஏற்கனவே கோப்பு புறக்கணிக்க அதாவது, அது W கடத்தலாம்

1005
01:02:13,510 --> 01:02:18,070
நாங்கள், அவர்கள் அதற்கு பதில் overriding கோப்பு முடிவிற்கு append எந்த ஒரு ஒரு கடத்தலாம்

1006
01:02:18,070 --> 01:02:22,730
அல்லது நாம் அதாவது, r குறிப்பிட முடியும், கோப்பு படிக்க மட்டுமே திறக்க அனுமதிக்க.

1007
01:02:22,730 --> 01:02:24,890
நிரல், கோப்பு எந்த மாற்றங்கள் செய்ய முயற்சித்தால் நீங்கள்

1008
01:02:24,890 --> 01:02:30,140
அவர்கள் கத்துகிறாய் அவர்கள் அதை செய்ய விடுவதில்லை.

1009
01:02:30,140 --> 01:02:33,320
இறுதியாக, நாம், அதை நடவடிக்கைகளை செய்து முடித்ததும், கோப்பு முடித்துவிட்டீர்கள்

1010
01:02:33,320 --> 01:02:35,860
நாம் கோப்பு மூட உறுதி செய்ய வேண்டும்.

1011
01:02:35,860 --> 01:02:38,830
எனவே உங்கள் திட்டம் இறுதியில், மீண்டும் அவர்களை கடந்து செல்கிறோம்

1012
01:02:38,830 --> 01:02:42,120
நீங்கள் திறந்து, மற்றும் அதை மூடிவிட்டு இந்த கோப்பு என்று.

1013
01:02:42,120 --> 01:02:44,650
இந்த உனக்கு உறுதி செய்ய வேண்டும் என்று முக்கியமான ஒன்று.

1014
01:02:44,650 --> 01:02:47,180
எனவே நீங்கள் ஒரு கோப்பை திறக்க முடியும் நினைவில் நீ, கோப்பு எழுத முடியும்

1015
01:02:47,180 --> 01:02:51,270
கோப்பு செயல்பாடுகளை செய்ய, ஆனால் நீங்கள் இறுதியில் கோப்பு மூட வேண்டும்.

1016
01:02:51,270 --> 01:02:53,270
>> அடிப்படை கோப்பு எந்த கேள்விகளுக்கும் நான் / O? ஆமாம்?

1017
01:02:53,270 --> 01:02:58,050
[மாணவர் கேள்வி, புரிந்து]

1018
01:02:58,050 --> 01:03:02,480
சரி இங்கே. கேள்வி, இந்த log.txt கோப்பு எங்கே தோன்றும்?

1019
01:03:02,480 --> 01:03:07,890
நீங்கள் அதை log.txt கொடுத்தால் நன்றாக,, அது இயங்கக்கூடிய அதே அடைவில் அது உருவாக்குகிறது.

1020
01:03:07,890 --> 01:03:10,500
எனவே you're என்றால் - >> [மாணவர் கேள்வி, புரிந்து]

1021
01:03:10,500 --> 01:03:18,830
ஆம். அதே கோப்புறையில், அல்லது அதே அடைவில், நீங்கள் அழைக்க வேண்டும்.

1022
01:03:18,830 --> 01:03:21,400
இப்போது நினைவகம், ஸ்டாக், மற்றும் குவியல்.

1023
01:03:21,400 --> 01:03:23,400
எனவே கணினி அமைக்கப்பட்டன நினைவக எப்படி இருக்கிறது?

1024
01:03:23,400 --> 01:03:26,270
சரி, நீங்கள் இங்கே இந்த தொகுதி வகையான நினைவக கற்பனை செய்யலாம்.

1025
01:03:26,270 --> 01:03:30,260
மற்றும் நினைவகத்தில் நாம் அங்கு சிக்கி குவியல், மற்றும் அங்கு கீழே என்று ஸ்டேக் என்று என்ன இருக்கிறது.

1026
01:03:30,260 --> 01:03:34,480
மற்றும் குவியல் கீழ்நோக்கி வளரும் மற்றும் ஸ்டாக் மேல்நோக்கி வளரும்.

1027
01:03:34,480 --> 01:03:38,620
டாமி குறிப்பிட்டுள்ளார் அதனால் - ஓ, நல்ல, நாம் நான் ஒரு இரண்டாவது கிடைக்கும் இந்த மற்ற 4 பிரிவுகளாக வேண்டும் -

1028
01:03:38,620 --> 01:03:42,890
டாமி முந்தைய என, நீங்கள் அவரது செயல்பாடுகளை தங்களை அழைத்து ஒருவருக்கொருவர் அழைப்பு எப்படி தெரியும்?

1029
01:03:42,890 --> 01:03:44,930
அவர்கள் ஸ்டாக் சட்டகமானது இந்த வகையான கட்டமைக்க.

1030
01:03:44,930 --> 01:03:47,360
நன்றாக, முக்கிய அழைப்புகள் foo, foo ஸ்டாக் வைக்க வந்தால்.

1031
01:03:47,360 --> 01:03:52,430
Foo அழைப்பு பார், பார் ஸ்டாக் வைக்க, மற்றும் பிறகு ஸ்டாக் வைக்க போகிறான் என்று.

1032
01:03:52,430 --> 01:03:57,040
அவர்கள் திரும்பி மற்றும், அவர்கள் ஒவ்வொரு ஸ்டேக் எடுத்து வருகிறது.

1033
01:03:57,040 --> 01:04:00,140
இந்த இடங்களில் ஒவ்வொரு மற்றும் நினைவக என்ன நடத்த?

1034
01:04:00,140 --> 01:04:03,110
நன்றாக, உரை பகுதி இது மேல், நிரலில் உள்ளது.

1035
01:04:03,110 --> 01:04:06,390
இயந்திர குறியீடு அதனால், அங்கு தான், ஒரு முறை உங்கள் நிரலை கம்பைல்.

1036
01:04:06,390 --> 01:04:08,520
அடுத்து, எந்த உலக மாறிகள் துவக்கப்படும்.

1037
01:04:08,520 --> 01:04:12,660
>> எனவே, நீங்கள் உங்கள் திட்டத்தில் உலக மாறிகள் வேண்டும், மற்றும் நீங்கள் ஒரு = 5, அப்படி சொல்ல

1038
01:04:12,660 --> 01:04:15,260
அந்த பிரிவில் வைத்து, வலது என்று கீழ் விடும் என்று,

1039
01:04:15,260 --> 01:04:18,990
நீங்கள், ஒரு INT இது எந்த uninitialized உலக தரவு, வேண்டும்

1040
01:04:18,990 --> 01:04:20,990
ஆனால் நீங்கள் அதை ஏதாவது சமமாக தான் சொல்ல வேண்டாம்.

1041
01:04:20,990 --> 01:04:23,870
இந்த உலக மாறிகள், எனவே அவர்கள் முக்கிய வெளியே தான் உணர.

1042
01:04:23,870 --> 01:04:28,560
இந்த பிரகடனம் ஆனால் துவக்கப்படும் என்று எந்த உலக மாறிகள் பொருள்.

1043
01:04:28,560 --> 01:04:32,310
எனவே குவியல் என்ன? நினைவக நாம் சிறிதுநேரத்தில் கிடைக்கும் எந்த malloc, பயன்படுத்தி ஒதுக்கீடு.

1044
01:04:32,310 --> 01:04:35,990
இறுதியாக, ஸ்டாக் நீங்கள் எந்த உள்ளூர் மாறிகள் வேண்டும்

1045
01:04:35,990 --> 01:04:39,950
எந்த செயல்பாடுகளை அவர்களின் அளவுருக்கள் எந்த கூப்பிடுகிறேன்.

1046
01:04:39,950 --> 01:04:43,720
கடந்த விஷயம், நீங்கள் உண்மையில், சூழல் மாறிகளை என்ன தெரியும் இல்லை

1047
01:04:43,720 --> 01:04:46,700
ஆனால் நீங்கள் நிரலை போதெல்லாம், தொடர்புடைய ஒன்று போல இருக்கிறது,

1048
01:04:46,700 --> 01:04:49,550
இந்த திட்டம் நடத்தினார் நபரின் பெயர் உள்ளது.

1049
01:04:49,550 --> 01:04:51,550
என்று கீழே உள்ள மாதிரி இருக்க போகிறது.

1050
01:04:51,550 --> 01:04:54,540
அறுபதின்ம மதிப்புகள் இது நினைவக முகவரிகள், அடிப்படையில்,

1051
01:04:54,540 --> 01:04:58,170
0 உயர்மட்ட தொடக்கத்தில் மதிப்புகள், அவர்கள் கீழே அனைத்து வழி கீழே செல்லுங்கள்.

1052
01:04:58,170 --> 01:05:00,440
இந்த வழக்கில், நீங்கள் 32 பிட் கணினியில் என்றால்,

1053
01:05:00,440 --> 01:05:05,390
கீழே உள்ள முகவரியை என்று 32 பிட்கள் ஏனெனில், AF தொடர்ந்து, 0x போகிறது

1054
01:05:05,390 --> 01:05:10,890
இதில் 8 பைட்டுகள் ஆகும், இந்த வழக்கில் 8 பைட்டுகள் 8 அறுபதின்ம இலக்கங்கள் ஒத்துள்ளது.

1055
01:05:10,890 --> 01:05:20,110
எனவே இங்கு நீங்கள் விரும்பும், 0xffffff போகிறது, மற்றும் அங்கு நீங்கள் 0 போகிறது.

1056
01:05:20,110 --> 01:05:23,660
அதனால் என்ன குறிப்புகள் உள்ளன? நீங்கள் சில முன் பகுதியில் இந்த விவாதிக்கப்படுகின்றன இல்லை.

1057
01:05:23,660 --> 01:05:26,660
ஆனால் நாம் விரிவுரையில் அதை போனீர்கள், ஒரு சுட்டிக்காட்டி ஒரு தரவு வகை உள்ளது

1058
01:05:26,660 --> 01:05:34,030
அதற்கு பதிலாக 50 போன்ற மதிப்பு சில வகையான, இது நினைவக சில இடம் முகவரியை சேமித்து இதில் கடைகள்,.

1059
01:05:34,030 --> 01:05:36,020
என்று நினைவகம் போன்ற [புரிந்து].

1060
01:05:36,020 --> 01:05:41,120
இந்த வழக்கில், நாம் தான் என்ன, நாம், ஒரு முழு எண் அல்லது ஒரு முழு எண்ணாக * ஒரு சுட்டிக்காட்டி உள்ளது

1061
01:05:41,120 --> 01:05:46,210
அது 0xDEADBEEF இந்த அறுபதின்ம முகவரியை கொண்டுள்ளது.

1062
01:05:46,210 --> 01:05:50,880
>> அதனால் என்ன நாம் நினைவு சில இடத்தில் இந்த சுட்டிக்காட்டி புள்ளிகள், இப்போது, தான்,

1063
01:05:50,880 --> 01:05:56,020
அந்த ஒரு விஷயம், மதிப்பு 50 இந்த நினைவு இடத்தில் உள்ளது.

1064
01:05:56,020 --> 01:06:01,810
சில 32 பிட் கணினிகளில், அனைத்து 32 பிட் கணினிகளில், சுட்டிகள் 32 பிட்கள் அல்லது 4 பைட்டுகள் எடுத்து.

1065
01:06:01,810 --> 01:06:06,020
ஆனால், உதாரணத்திற்கு, ஒரு 64 பிட் கணினியில், சுட்டிகள் 64 துண்டுகள்.

1066
01:06:06,020 --> 01:06:08,040
அதனால் நீங்கள் மனதில் கொள்ள வேண்டும் என்று நினைக்கும் விஷயம்.

1067
01:06:08,040 --> 01:06:12,310
அதனால் ஒரு முடிவுக்கு பிட் கணினியில், ஒரு சுட்டிக்காட்டி இறுதியில் பிட்கள் நீளமாக உள்ளது.

1068
01:06:12,310 --> 01:06:17,320
சுட்டிகள், கூடுதல் விஷயங்களை இல்லாமல் வகையான ஜீரணிக்க கடினம்

1069
01:06:17,320 --> 01:06:20,300
எனவே மாறும் நினைவக ஒதுக்கீடு ஒரு உதாரணம் மூலம் செல்லலாம்.

1070
01:06:20,300 --> 01:06:25,130
, என்ன மாறும் நினைவக ஒதுக்கீடு நீங்கள் இல்லை, அல்லது நாம் malloc அழைக்க என்ன

1071
01:06:25,130 --> 01:06:29,280
அதை நீங்கள் செட் வெளியே தரவு ஒருவித ஒதுக்க முடியும்.

1072
01:06:29,280 --> 01:06:31,830
இந்த தரவு மாதிரி திட்டத்தின் கால அளவு மேலும் நிரந்தரமானது.

1073
01:06:31,830 --> 01:06:36,430
உனக்கு தெரியும் என்பதால், நீங்கள் ஒரு செயல்பாடு உள்ளே x, அந்த செயல்பாடு மீண்டும் அறிவிக்க வேண்டும்,

1074
01:06:36,430 --> 01:06:40,910
இனி x சேமிக்கப்படும் என்று தரவு அணுகல்.

1075
01:06:40,910 --> 01:06:44,420
என்ன சுட்டிகள் எங்களுக்கு செய்யட்டும் அவர்கள் எங்களுக்கு நினைவகம் அல்லது கடை மதிப்புகள் சேமிக்க விடப்படும்

1076
01:06:44,420 --> 01:06:46,840
அதாவது நினைவகம் வேறு பிரிவில், குவியல் உள்ள.

1077
01:06:46,840 --> 01:06:49,340
இப்போது நாங்கள் நீண்ட நாம் ஒரு சுட்டிக்காட்டி வேண்டும் என, செயல்பாடு வெளியே வர

1078
01:06:49,340 --> 01:06:54,960
நினைவகத்தில் அந்த இடத்தில், நாம் என்ன செய்ய முடியும் நாங்கள் அங்கே மதிப்புகள் பார்க்க முடியும்.

1079
01:06:54,960 --> 01:06:58,020
இது ஒரு உதாரணம் பார்க்கிறேன்: இந்த மீண்டும் எங்கள் நினைவக அமைப்பு ஆகும்.

1080
01:06:58,020 --> 01:07:00,050
நாங்கள் முக்கிய, இந்த செயல்பாடு உள்ளது.

1081
01:07:00,050 --> 01:07:06,870
என்ன அது தான் - பரவாயில்லை, மிகவும் எளிமையான, வலது -? Int x = 5, என்று தான் முக்கிய உள்ள ஸ்டாக் ஒரு மாறி விட்டது.

1082
01:07:06,870 --> 01:07:12,450
>> மறுபுறம், இப்போது நாம் செயல்பாடு giveMeThreeInts அழைக்கும் ஒரு சுட்டிக்காட்டி அறிவிக்க.

1083
01:07:12,450 --> 01:07:16,800
எனவே இப்போது நாம் இந்த செயல்பாடு போக, அதை நாம் ஒரு புதிய ஸ்டாக் சட்டகமானது உருவாக்க.

1084
01:07:16,800 --> 01:07:20,440
எனினும், இந்த ஸ்டேக் சட்டத்தில், நாம், int * திறக்க பிரகடனம்

1085
01:07:20,440 --> 01:07:23,210
இது எங்களுக்கு mallocs 3 முழு இல்.

1086
01:07:23,210 --> 01:07:25,880
எனவே எண்ணாக அளவு, இந்த int எப்படி பல பைட்டுகள் நமக்கு கொடுக்கும்

1087
01:07:25,880 --> 01:07:29,620
மற்றும் malloc நமக்கு கொடுக்கிறது என்று குவியல் இடத்தை பல பைட்டுகள்.

1088
01:07:29,620 --> 01:07:32,890
இந்த வழக்கில், நாம், 3 முழு போதுமான இடத்தை உருவாக்கி

1089
01:07:32,890 --> 01:07:36,830
மற்றும் குவியல் நான் அதிக வரை அதை இழுத்து நான் ஏன் இது, அங்கு வழி.

1090
01:07:36,830 --> 01:07:42,900
நாம் செய்து முடித்ததும், நாம் இங்கே திரும்பி வந்து, நீங்கள் மட்டும் 3 ints திரும்ப வேண்டும்,

1091
01:07:42,900 --> 01:07:47,000
மற்றும் அந்த நினைவக எங்கே இந்த வழக்கில், முகவரி கொடுக்கிறது.

1092
01:07:47,000 --> 01:07:51,250
நாம் சுட்டிக்காட்டி = சுவிட்ச் அமைக்க, மற்றும் அங்கு நாம் மற்றொரு சுட்டிக்காட்டி இருக்கிறது.

1093
01:07:51,250 --> 01:07:54,550
ஆனால் என்ன செயல்பாட்டை மீண்டும் இங்கே அடுக்கப்பட்ட மற்றும் மறைந்துவிடும் என்று.

1094
01:07:54,550 --> 01:07:59,250
எனவே திறக்க போகிறது, ஆனால் நாம் இன்னும் அங்கு முகவரி பராமரிக்க

1095
01:07:59,250 --> 01:08:01,850
அந்த 3 முழு மெயின்களின் உள்ளே இருக்கும்.

1096
01:08:01,850 --> 01:08:06,180
இந்த தொகுப்பில், சுட்டிகள், அடுக்கப்பட்ட சட்டத்திற்கு உள்ளமைவாக ஆகியவற்றை நோக்காகக்கொண்ட இருக்கும்

1097
01:08:06,180 --> 01:08:09,860
ஆனால் அவை பார்க்கவும் நினைவக குவியல் இருக்கிறது.

1098
01:08:09,860 --> 01:08:12,190
>> அந்த உணர்வு ஏற்படுத்தும்?

1099
01:08:12,190 --> 01:08:14,960
[மாணவர்] நீங்கள் மறுபடியும் முடியவில்லை? >> [ஜோசப்] ஆமாம்.

1100
01:08:14,960 --> 01:08:20,270
நான் மீண்டும் ஒரு சிறிது சென்றால் எனவே, நீங்கள் திறக்க ஒதுக்கீடு என்று பார்க்க

1101
01:08:20,270 --> 01:08:23,500
அங்கு குவியல் சில நினைவகம்.

1102
01:08:23,500 --> 01:08:28,680
இந்த விழாவில், giveMeThreeInts வருமானம், இங்கே இந்த ஸ்டேக் காணாமல் போகும்.

1103
01:08:28,680 --> 01:08:35,819
மற்றும் இந்த வழக்கில் மாறிகள் எந்த, அடுக்கப்பட்ட சட்டத்தில் ஒதுக்கீடு என்று இந்த சுட்டியை வைத்து.

1104
01:08:35,819 --> 01:08:39,649
நாம் திறக்க வந்தார் பின்னர் அந்த மறைந்து போய், ஆனால்

1105
01:08:39,649 --> 01:08:46,330
நாம் = திறக்க, சுட்டிக்காட்டி இப்போது திறக்க இருந்தது இடம் அதே நினைவக சுட்டிக்காட்ட நடக்கிறது சுட்டிக்காட்டி அமைக்க.

1106
01:08:46,330 --> 01:08:50,370
எனவே இப்போது, நாம் திறக்க, உள்ளூர் சுட்டிக்காட்டி, இழக்க கூட

1107
01:08:50,370 --> 01:08:59,109
நாம் இன்னும் அந்த மாறி சுட்டிக்காட்டி உள்ளே குறிக்கின்ற என்ன நினைவக முகவரி தக்கவைத்து.

1108
01:08:59,109 --> 01:09:03,740
கேள்விகள்? நீங்கள் பிரிவில் அதை போகவில்லை என்றால் ஒரு குழப்பமான தலைப்பு என்ன இருக்க முடியும்.

1109
01:09:03,740 --> 01:09:09,240
நாங்கள், உங்கள் TF நிச்சயமாக அதை போய் மற்றும் நிச்சயமாக நாம் கேள்விகளுக்கு பதிலளிக்க முடியாது

1110
01:09:09,240 --> 01:09:11,500
இந்த ஆய்வு அமர்வின் முடிவில்.

1111
01:09:11,500 --> 01:09:14,220
ஆனால் இந்த ஒரு சிக்கலான தலைப்பு வகை, மற்றும் நான் காட்ட போகிறோம் என்று இன்னும் உதாரணங்கள் உண்டு

1112
01:09:14,220 --> 01:09:18,790
அந்த சுட்டிகள் உண்மையில் என்ன தெளிவுபடுத்த உதவும்.

1113
01:09:18,790 --> 01:09:22,500
>> இந்த வழக்கில், சுட்டிகள், வரிசைகள் சமமானதாக இருக்கும்

1114
01:09:22,500 --> 01:09:25,229
அதனால் நான் ஒரு முழு எண்ணாக வரிசை அதே காரியத்தை இந்த சுட்டியை பயன்படுத்தலாம்.

1115
01:09:25,229 --> 01:09:29,840
அதனால் நான், 0 என்ற அட்டவணையிடுவது, மற்றும் 1 முதல் முழு மாற்றம்

1116
01:09:29,840 --> 01:09:39,689
2 இரண்டாவது முழு மாற்றம், மற்றும் 3 வது முழு 3.

1117
01:09:39,689 --> 01:09:44,210
சுட்டிகள் மிகவும் அதிக. நன்றாக, Binky நினைவு.

1118
01:09:44,210 --> 01:09:48,319
இந்த வழக்கில், நாம் ஒரு சுட்டிக்காட்டி ஒதுக்கீடு, அல்லது நாம் ஒரு சுட்டிக்காட்டி அறிவித்தார்

1119
01:09:48,319 --> 01:09:52,760
ஆனால் ஆரம்பத்தில், நான் ஒரு சுட்டிக்காட்டி அறிவித்தார் போது, அது எங்கு நினைவகத்தில் சுட்டி காட்டியது இல்லை.

1120
01:09:52,760 --> 01:09:54,930
அது உள்ளே வெறும் குப்பை மதிப்புகள் தான்.

1121
01:09:54,930 --> 01:09:56,470
அதனால் நான் இந்த சுட்டியை சுட்டி காட்டியது அமைந்துள்ள தெரியாது.

1122
01:09:56,470 --> 01:10:01,630
அது 0 மற்றும் 1 அது முதலில் அறிவிக்கப்பட்டது அங்கு நிறைந்த ஒரு முகவரி.

1123
01:10:01,630 --> 01:10:04,810
நான் அதை malloc அழைப்பு வரை நான் இந்த ஒன்றும் செய்ய முடியாது

1124
01:10:04,810 --> 01:10:08,390
பின்னர் என்னை நான் உள்ளே மதிப்புகள் முடியும் அங்கு குவியல் ஒரு சிறிய இடைவெளி கொடுக்கிறது.

1125
01:10:08,390 --> 01:10:11,980
மீண்டும், நான் இந்த நினைவகம் உள்ளே என்ன என்று எனக்கு தெரியாது.

1126
01:10:11,980 --> 01:10:16,780
அதனால் நான் என்ன செய்ய வேண்டும் முதல் விஷயம் அமைப்பு போதுமான நினைவகம் இல்லை என்பதை தான்

1127
01:10:16,780 --> 01:10:20,850
நான் இந்த சோதனை செய்கிறேன் அதனால் தான் முதல் இடம், 1 முழு திரும்ப கொடுக்க.

1128
01:10:20,850 --> 01:10:25,020
சுட்டிக்காட்டி பூஜ்ய இருந்தால், அந்த, அது போதுமான இடைவெளி அல்லது வேறு சில பிழை ஏற்பட்டது இல்லை என்று அர்த்தம்

1129
01:10:25,020 --> 01:10:26,320
அதனால் நான் என் திட்டத்தை வெளியே வெளியேற வேண்டும்.

1130
01:10:26,320 --> 01:10:29,400
 அது வெற்றி செய்தால் ஆனால், இப்போது நான் அந்த சுட்டியை பயன்படுத்தலாம்

1131
01:10:29,400 --> 01:10:35,020
என்ன * சுட்டிக்காட்டி இல்லை முகவரியை எங்கே அது பின்வருமாறு உள்ளது

1132
01:10:35,020 --> 01:10:38,480
அந்த மதிப்பு, மற்றும் 1 க்கு சமமாக அமைக்க வேண்டும்.

1133
01:10:38,480 --> 01:10:41,850
அந்த நினைவு இருந்த என்றால் இங்கு, நாம் பரிசீலித்துக்கொண்டிருக்கிறோம்.

1134
01:10:41,850 --> 01:10:45,380
>> நீங்கள் அதை உள்ளது என்று ஒரு முறை, நீங்கள் அதை முடியும்

1135
01:10:45,380 --> 01:10:50,460
என்ன மதிப்பு நீங்கள் அதை கொடுக்க வேண்டும்; இந்த வழக்கு 1.

1136
01:10:50,460 --> 01:10:53,060
நாம் அது முடித்துவிட்டீர்கள், நீங்கள் என்று சுட்டிக்காட்டி விடுவிக்க வேண்டும்

1137
01:10:53,060 --> 01:10:57,160
நாம் கணினியில் நீங்கள் முதலில் கேட்ட அந்த நினைவு திரும்ப பெற வேண்டும், ஏனெனில்.

1138
01:10:57,160 --> 01:10:59,690
ஏனெனில் கணினி நாம் முடித்துவிட்டீர்கள் போது தெரியாது.

1139
01:10:59,690 --> 01:11:02,510
இந்த வழக்கில் நாம் வெளிப்படையாக அதை சொல்கிறாய், சரி, நாம் அந்த நினைவு முடித்துவிட்டீர்கள்.

1140
01:11:02,510 --> 01:11:10,780
வேறு சில வழிமுறைகளை அது தேவை என்றால், வேறு சில நிரல் தேவைப்படுகிறது, முன்னால் சென்று எடுத்து கொள்ளலாம்.

1141
01:11:10,780 --> 01:11:15,110
என்ன நாங்கள் என்ன செய்ய முடியும் நாங்கள் தொகுப்பில் உள்ளூர் மாறிகளின் முகவரியை பெற முடியும்.

1142
01:11:15,110 --> 01:11:19,080
எனவே int x முக்கிய அடுக்கப்பட்ட சட்டத்தில் உள்ளே இருக்கும்.

1143
01:11:19,080 --> 01:11:23,060
நாம் இந்த ampersand பயன்படுத்த போது, இந்த மற்றும் ஆபரேட்டர், என்ன அது தான்

1144
01:11:23,060 --> 01:11:27,310
அது x எடுத்து, மற்றும் x நினைவகத்தில் சில தரவு, ஆனால் அது ஒரு முகவரி.

1145
01:11:27,310 --> 01:11:33,790
அது எங்கோ அமைந்துள்ள. இந்த என்ன அழைப்பு & x, உள்ளது அது நம்மை x முகவரி கொடுக்கிறது.

1146
01:11:33,790 --> 01:11:38,430
இப்படி செய்வதால், நாம் x நினைவகத்தில் எங்கே என்று சுட்டிக்காட்டி புள்ளி செய்கிறாய்.

1147
01:11:38,430 --> 01:11:41,710
இப்போது நாம் மட்டும் * போன்ற ஏதாவது x, நாங்கள் 5 திரும்ப பெற போகிறோம்.

1148
01:11:41,710 --> 01:11:43,820
நட்சத்திர அதை dereferencing அழைக்கப்படுகிறது.

1149
01:11:43,820 --> 01:11:46,640
நீங்கள் முகவரியை பின்பற்ற நீங்கள் அங்கு சேமித்து அதை மதிப்பு கிடைக்கும்.

1150
01:11:51,000 --> 01:11:53,310
>> எந்த கேள்விகள்? ஆமாம்?

1151
01:11:53,310 --> 01:11:56,500
நீங்கள் 3-கூரான பொருளை செய்யாவிட்டால் [மாணவர், அது இன்னமும் தொகுக்க?

1152
01:11:56,500 --> 01:11:59,490
ஆம். நீங்கள் 3-சுட்டிக்காட்டி செய் என்றால், அது இன்னும், தொகுக்க நடக்கிறது

1153
01:11:59,490 --> 01:12:02,720
ஆனால் நான், இரண்டாவது என்ன நீங்கள் காட்ட, அந்த செய்யாமல் நான்

1154
01:12:02,720 --> 01:12:04,860
என்று நாம் ஒரு நினைவக கசிவு அழைக்க என்ன. கணினி கொடுக்கும்

1155
01:12:04,860 --> 01:12:07,850
அதன் நினைவக காப்பு, அதனால் ஒரு பின்னர் திட்டத்தை குவிக்க போகும் போது

1156
01:12:07,850 --> 01:12:10,940
அதை பயன்படுத்தி, வேறு எதுவும் அதை பயன்படுத்த முடியும் நினைவகம் என்று.

1157
01:12:10,940 --> 01:12:15,750
நீங்கள் எப்போதும் உங்கள் கணினியில் 1.5 மில்லியன் கிலோபைட்டுகளை ஃபயர்ஃபாக்ஸ் பார்த்த போது,

1158
01:12:15,750 --> 01:12:17,840
பணி மேலாளர், அந்த நடக்கிறது என்ன.

1159
01:12:17,840 --> 01:12:20,760
நீங்கள் அவர்கள் கையாள முடியாது என்று திட்டம் ஒரு நினைவக கசிவு இல்லை.

1160
01:12:23,080 --> 01:12:26,240
எனவே எப்படி சுட்டிக்காட்டி கணித வேலை செய்கிறது?

1161
01:12:26,240 --> 01:12:29,480
நன்றாக, சுட்டிக்காட்டி கணித ஒரு வரிசைக்கு சென்று போன்ற திருப்பு வகை.

1162
01:12:29,480 --> 01:12:36,370
இந்த வழக்கில், நான் ஒரு சுட்டிக்காட்டி வேண்டும், மற்றும் நான் என்ன செய்ய நான் முதல் உறுப்பு செய்ய சுட்டிக்காட்டி புள்ளி வைக்க உள்ளது

1163
01:12:36,370 --> 01:12:42,100
நான் ஒதுக்கீடு செய்த 3 முழுஎண்களின் இந்த வரிசைக்கு.

1164
01:12:42,100 --> 01:12:46,670
அதனால் இப்போது நான் என்ன செய்ய வேண்டும், நட்சத்திர சுட்டிக்காட்டி தான் பட்டியலில் முதல் உறுப்பு மாற்றுகிறது.

1165
01:12:46,670 --> 01:12:49,140
இங்கு நட்சத்திர சுட்டிக்காட்டி +1 புள்ளிகள்.

1166
01:12:49,140 --> 01:12:53,140
எனவே சுட்டிக்காட்டி இங்கு, சுட்டிக்காட்டி +1 இங்கு, சுட்டிக்காட்டி +2 இங்கு உள்ளது.

1167
01:12:53,140 --> 01:12:56,610
>> அதனால் தான் 1 சேர்த்து இந்த வரிசை சேர்ந்து நகரும் அதே விஷயம்.

1168
01:12:56,610 --> 01:12:59,880
நாம் என்ன தான், நாம் சுட்டிக்காட்டி +1 செய்யும் போது நீங்கள், இங்கு முகவரியை பெற

1169
01:12:59,880 --> 01:13:04,180
இங்கு உள்ள மதிப்பு பெறுவதற்காக, நீங்கள் முழு வெளிப்பாடு இருந்து ஒரு நட்சத்திரம் வைத்து

1170
01:13:04,180 --> 01:13:05,990
இது dereference வேண்டும்.

1171
01:13:05,990 --> 01:13:09,940
எனவே, இந்த விஷயத்தில், நான், 1 இந்த வரிசையில் முதல் இடம் அமைப்பதில்

1172
01:13:09,940 --> 01:13:13,970
2 இரண்டாவது இடம், மற்றும் 3 மூன்றாம் இடம்.

1173
01:13:13,970 --> 01:13:18,180
என்ன நான் இங்கு செய்கிறேன், நான் எங்கள் சுட்டிக்காட்டி +1 அச்சிடும் நான் இல்லை

1174
01:13:18,180 --> 01:13:19,970
இது தான் எனக்கு 2 கொடுக்கிறது.

1175
01:13:19,970 --> 01:13:23,650
இப்போது, நான் சுட்டிக்காட்டி உயர்த்துவதன், அதனால் சுட்டிக்காட்டி சுட்டிக்காட்டி +1 க்கு சமமாக

1176
01:13:23,650 --> 01:13:26,780
இது முன்னோக்கி அது நகர்கிறது.

1177
01:13:26,780 --> 01:13:30,810
அதனால் இப்போது நான் சுட்டிக்காட்டி +1 அவுட் அச்சிட என்றால், சுட்டிக்காட்டி +1, இப்போது 3

1178
01:13:30,810 --> 01:13:33,990
இந்த வழக்கில் 3 அவுட் அச்சிடுகிறது.

1179
01:13:33,990 --> 01:13:36,560
மற்றும் இலவச ஏதோ, நான் அதை கொடுக்க வேண்டும் என்று சுட்டிக்காட்டி பொருட்டு

1180
01:13:36,560 --> 01:13:40,540
நான் malloc இருந்து திரும்ப பெற்ற அணி தொடக்கத்தில் சுட்டி.

1181
01:13:40,540 --> 01:13:43,430
நான் இங்கே 3 அழைக்க இருந்தால் அதனால், இந்த வழக்கில், இந்த, வலது முடியாது

1182
01:13:43,430 --> 01:13:45,070
அது அணியின் மத்தியில் தான்.

1183
01:13:45,070 --> 01:13:48,820
நான் அசல் இடம் பெற கழித்து வேண்டும்

1184
01:13:48,820 --> 01:13:50,420
நான் அதை விடுவிக்க முடியாது முன் ஆரம்ப முதல் இடத்தில்.

1185
01:13:56,300 --> 01:13:58,450
எனவே, இங்கு அதிக ஈடுபட்டுள்ள எடுத்துக்காட்டு.

1186
01:13:58,450 --> 01:14:03,360
இந்த வழக்கில், நாம் ஒரு பாத்திரம் வரிசையில் 7 எழுத்துக்கள் ஒதுக்கீடு.

1187
01:14:03,360 --> 01:14:06,480
>> இந்த வழக்கில் நாம் செய்கிறோம் என்ன, நாம் அவர்களுக்கு முதல் 6 மீது தேடுகிறது நீங்கள் தான்

1188
01:14:06,480 --> 01:14:09,900
நாம் இசட் அவற்றை அமைப்பதற்கு

1189
01:14:09,900 --> 01:14:13,350
எனவே, முழு எண்ணாக நான் = 0, i> 6, நான் + +

1190
01:14:13,350 --> 01:14:16,220
எனவே, சுட்டிக்காட்டி + நான், இந்த விஷயத்தில், நமக்கு கொடுப்பேன்

1191
01:14:16,220 --> 01:14:20,860
சுட்டிக்காட்டி, சுட்டிக்காட்டி +1, சுட்டிக்காட்டி +2, சுட்டிக்காட்டி +3, மற்றும் பல மற்றும் முன்னும் பின்னுமாக வட்டத்திற்கு.

1192
01:14:20,860 --> 01:14:24,040
என்ன செய்ய போகிறது, அது மதிப்பு பெற, dereferences அந்த முகவரியை பெறும் என்று

1193
01:14:24,040 --> 01:14:27,440
ஒரு இசட் மற்றும் மாற்றங்கள் மதிப்பு

1194
01:14:27,440 --> 01:14:30,350
பின்னர் இறுதியில் சரி, இந்த ஒரு சரம் நினைவிருக்கிறதா?

1195
01:14:30,350 --> 01:14:33,560
அனைத்து சரங்களின் பூஜ்ய முடக்கப்படும் கதாபாத்திரம் முடிவடைய வேண்டும்.

1196
01:14:33,560 --> 01:14:38,620
எனவே, நான் என்ன செய்ய சுட்டிக்காட்டி 6 நான் உள்ளே பூஜ்ய அழிப்பு தன்மையை வைத்து தான்

1197
01:14:38,620 --> 01:14:43,980
இப்போது நான் அடிப்படையில் இங்கு என்ன செய்து கொண்டிருக்கிறேன், ஒரு சரம் ஐந்து printf சரியான செயல்படுத்தி வருகிறது?

1198
01:14:43,980 --> 01:14:46,190
>> எனவே, போது printf இப்போது அது ஒரு சரம் இறுதியில் அடைந்தது போது?

1199
01:14:46,190 --> 01:14:48,230
அது வெற்று முடக்கப்படும் தன்மையை எம் போது.

1200
01:14:48,230 --> 01:14:52,030
எனவே, இந்த விஷயத்தில், இந்த அணி தொடக்கத்தில் எனது அசல் சுட்டிக்காட்டி புள்ளிகள்.

1201
01:14:52,030 --> 01:14:56,410
நான் முதல் எழுத்து அவுட் அச்சிட. நான் ஒரு வழியாக அதை நகர்த்த.

1202
01:14:56,410 --> 01:14:58,420
நான் அந்த பாத்திரத்தை வெளியே அச்சிட. நான் அதை நகர்த்த.

1203
01:14:58,420 --> 01:15:02,180
மற்றும் நான் அடையும் வரை இதை வைத்து.

1204
01:15:02,180 --> 01:15:07,750
இப்போது இறுதியில் * சுட்டிக்காட்டி நான் dereference இந்த வெற்று முடக்கப்படும் தன்மையை மீண்டும்.

1205
01:15:07,750 --> 01:15:11,780
அதனால் என் போது வளையம் என்று மதிப்பு பூஜ்ஜிய முடக்கப்படும் பாத்திரம் அல்ல மட்டுமே இயங்கும்.

1206
01:15:11,780 --> 01:15:13,770
எனவே, இப்போது நான் இந்த வட்டத்திற்கு வெளியே வெளியேறவும்.

1207
01:15:18,780 --> 01:15:21,180
அதனால் நான், இந்த சுட்டியை இருந்து 6 கழித்து என்றால்

1208
01:15:21,180 --> 01:15:22,860
நான் ஆரம்பத்தில் அனைத்து வழியில் செல்ல.

1209
01:15:22,860 --> 01:15:27,880
நான் அதை விடுவிக்க வேண்டும் தொடக்கத்தில் செல்ல வேண்டும், ஏனெனில் நினைவில் வைத்து கொள்ளுங்கள், நான் செய்கிறேன்.

1210
01:15:27,880 --> 01:15:30,270
>> எனவே, நான் அந்த நிறைய என்று எனக்கு தெரியும். எந்த கேள்விகள் உள்ளன?

1211
01:15:30,270 --> 01:15:31,870
தயவு செய்து, சரி?

1212
01:15:31,870 --> 01:15:36,610
[மாணவர் கேள்வி புரிந்து]

1213
01:15:36,610 --> 01:15:38,190
நீங்கள் சத்தமாக என்று சொல்ல முடியும்? மன்னிக்கவும்.

1214
01:15:38,190 --> 01:15:44,140
[மாணவர்] நீங்கள் சுட்டிக்காட்டி விடுதலை வலது முன் கடந்த ஸ்லைட் இல்,

1215
01:15:44,140 --> 01:15:47,300
நீங்கள் உண்மையில் சுட்டிக்காட்டி மதிப்பு மாறும்?

1216
01:15:47,300 --> 01:15:50,370
[ஜோசப்] எனவே, சரியான இங்கே. >> [மாணவர்] ஓ, சரி.

1217
01:15:50,370 --> 01:15:51,890
[ஜோசப்] எனவே, நான், ஒரு சுட்டிக்காட்டி கழித்தல் கழித்தல் வேண்டும்,

1218
01:15:51,890 --> 01:15:54,140
இது, நான் அதை விடுவித்து பிறகு மீண்டும் ஒன்று நகரும், மற்றும்

1219
01:15:54,140 --> 01:15:57,000
இந்த சுட்டியை அணி தொடக்கத்தில் சுட்டிக்காட்டினார் வேண்டும் என்பதால்.

1220
01:15:57,000 --> 01:16:00,420
நீங்கள் அந்த வரியை பின்னர் முடிந்திருந்தது [மாணவர்] ஆனால் தேவைப்படும் என்று.

1221
01:16:00,420 --> 01:16:03,130
நான் இந்த பிறகு நின்றிருந்தால் [ஜோசப்] எனவே, இந்த, ஒரு நினைவக கசிவு கருதப்படுகிறது

1222
01:16:03,130 --> 01:16:04,810
நான் இலவச இயக்க முடியவில்லை, ஏனெனில்.

1223
01:16:04,810 --> 01:16:11,290
[மாணவர்] நான் [புரிந்து] நீங்கள் சுட்டிக்காட்டி +1 [புரிந்து] வைத்திருந்தார் முதல் மூன்று கோடுகள் பிறகு.

1224
01:16:11,290 --> 01:16:13,140
[ஜோசப்] பத்திதான் ம்ம். எனவே, அங்கு கேள்விக்கு என்ன?

1225
01:16:13,140 --> 01:16:14,780
மன்னிக்கவும். இல்லை, இல்லை. தயவு செய்து, போ, போ.

1226
01:16:14,780 --> 01:16:16,870
[மாணவர்] எனவே, நீங்கள் சுட்டிகள் மதிப்பு மாறும்.

1227
01:16:16,870 --> 01:16:19,130
நீங்கள் சுட்டிக்காட்டி கழித்தல் கழித்தல் செய்ய இருந்திருக்காது.

1228
01:16:19,130 --> 01:16:19,730
[ஜோசப்] ஆமாம், சரியாக.

1229
01:16:19,730 --> 01:16:21,890
எனவே, நான் சுட்டிக்காட்டி +1 மற்றும் சுட்டிக்காட்டி +2 செய்யும் போது,

1230
01:16:21,890 --> 01:16:24,410
நான் சுட்டிக்காட்டி செய்யவில்லை சுட்டிக்காட்டி +1 க்கு சமமாக.

1231
01:16:24,410 --> 01:16:27,260
எனவே, சுட்டிக்காட்டி தான் அணி தொடக்கத்தில் சுட்டி.

1232
01:16:27,260 --> 01:16:31,460
, நான் பிளஸ் செய்யும் போது அதை மட்டுமே பிளஸ் சுட்டிக்காட்டி உள்ளே திரும்பி மதிப்பு அமைக்கிறது

1233
01:16:31,460 --> 01:16:33,550
அது உண்மையில் சேர்ந்து இந்த நகரும் என்று.

1234
01:16:36,860 --> 01:16:37,780
எல்லாம் சரி.

1235
01:16:40,550 --> 01:16:42,030
மேலும் கேள்விகள்?

1236
01:16:44,680 --> 01:16:47,790
>> இந்த பெரும் வகையான என்றால் மீண்டும், இந்த அமர்வு விவாதிக்கப்படுகின்றன.

1237
01:16:47,790 --> 01:16:50,710
அதை பற்றி உங்கள் போதனை சக கேளுங்கள், நாம் முடிவில் கேள்விகளுக்கு பதிலளிக்க முடியாது.

1238
01:16:53,510 --> 01:16:56,600
பொதுவாக நாம் இந்த கழித்து தான் செய்ய விரும்பவில்லை.

1239
01:16:56,600 --> 01:16:59,760
இந்த என்னை நான் வரிசையில் ஈடு நான் எவ்வளவு கண்காணிப்பதற்கான தேவைப்படுகிறது வேண்டும்.

1240
01:16:59,760 --> 01:17:04,520
எனவே, பொதுவாக, இந்த சுட்டியை கணித படைப்புகளை எப்படி விளக்குவது தான்.

1241
01:17:04,520 --> 01:17:07,970
ஆனால் நாம் வழக்கமாக செய்ய விரும்புகிறீர்கள், நாம் சுட்டிக்காட்டி நகலை உருவாக்க வேண்டும் என்று

1242
01:17:07,970 --> 01:17:11,640
நாம் சரம் சுற்றி நகரும் போது நாம் அந்த நகலை பயன்படுத்த வேண்டும்.

1243
01:17:11,640 --> 01:17:14,660
எனவே, இந்த விஷயத்தில் நீங்கள் நகல், முழு சரம் அச்சிட பயன்படுத்த

1244
01:17:14,660 --> 01:17:19,040
ஆனால் நாம், சுட்டிக்காட்டி கழித்து 6 போன்று செய்ய வேண்டும் அல்லது இந்த சென்றார் எவ்வளவு கண்காணிப்பதற்கான

1245
01:17:19,040 --> 01:17:22,700
நாம் உண்மையான புள்ளி இன்னமும் பட்டியலில் ஆரம்பத்தில் சுட்டிக்காட்டினார் என்று தான்

1246
01:17:22,700 --> 01:17:25,340
நாம் மாற்றங்கள் அனைத்து இந்த நகல் இருந்தது.

1247
01:17:25,340 --> 01:17:28,250
எனவே, பொதுவாக, உங்கள் அசல் சுட்டிக்காட்டி பிரதிகளை மாற்ற.

1248
01:17:28,250 --> 01:17:32,350
போன்ற வரிசைப்படுத்த வேண்டாம் - அசல் பிரதிகளை மாற்ற don't.

1249
01:17:32,350 --> 01:17:35,290
உங்கள் அசல் மட்டுமே பிரதிகள் மாற்ற முயற்சி.

1250
01:17:41,540 --> 01:17:44,870
நாம் printf கொண்டு சரம் போகும்போது, எனவே நீங்கள் கவனிக்கவில்லையா

1251
01:17:44,870 --> 01:17:48,990
நீ, நாம் வேறு dereferences செய்ததை போல, அது முன்னால் உள்ள ஒரு நட்சத்திர வைத்து உரிமை இல்லை?

1252
01:17:48,990 --> 01:17:54,180
நீங்கள் முழு சரம்% கள் எதிர்பார்க்கிறது அவுட் அச்சிட என்றால், ஒரு முகவரி

1253
01:17:54,180 --> 01:17:57,610
இந்த வழக்கு ஒரு சுட்டிக்காட்டி அல்லது எழுத்துக்கள் ஒரு வரிசை போல் இந்த விஷயத்தில்.

1254
01:17:57,610 --> 01:18:00,330
>> பாத்திரங்கள், கரி * கள், மற்றும் அணிகளை ஒன்று உள்ளது.

1255
01:18:00,330 --> 01:18:03,690
சுட்டிக்காட்டி எழுத்துக்கள் உள்ளது, மற்றும் எழுத்து வரிசைகள் தான் இருக்கும்.

1256
01:18:03,690 --> 01:18:05,720
எனவே, நாம் செய்ய வேண்டிய அனைத்து சுட்டிக்காட்டி உள்ள கடக்க வேண்டும்.

1257
01:18:05,720 --> 01:18:08,150
நாம் * சுட்டிக்காட்டி அல்லது அப்படி எதுவும் போன்ற செல்வதை இல்லை.

1258
01:18:13,110 --> 01:18:14,930
எனவே, கோவை மற்றும் குறிப்புகள் தான் இருக்கும்.

1259
01:18:14,930 --> 01:18:19,160
நீங்கள் x போல் செய்கிறீர்கள் போது இங்கு ஒரு அணியை [y],

1260
01:18:19,160 --> 01:18:21,960
என்ன இது முக்காடிட்டு செய்து அதை சொல்கிறாள், சரியா, அது, ஒரு பாத்திரம் வரிசை தான்

1261
01:18:21,960 --> 01:18:23,690
அது ஒரு சுட்டிக்காட்டி இருக்கிறது.

1262
01:18:23,690 --> 01:18:26,510
அதனால் x, அதையே தான்

1263
01:18:26,510 --> 01:18:28,650
மற்றும் அது என்ன, அது x க்கு y சேர்க்கிறது உள்ளது

1264
01:18:28,650 --> 01:18:31,820
அந்த நினைவகத்தில் முன்னேற்றம் அதே விஷயம் ஆகும்.

1265
01:18:31,820 --> 01:18:34,930
இப்போது X + Y, எங்களுக்கு முகவரி ஒருவித கொடுக்கிறது

1266
01:18:34,930 --> 01:18:37,570
நாம் முகவரியை dereference அல்லது செய்திகள் பின்பற்ற

1267
01:18:37,570 --> 01:18:41,640
நினைவகத்தில் உள்ள இடம் மற்றும் நாம் நினைவில் அந்த இடம் மதிப்பு வெளியே.

1268
01:18:41,640 --> 01:18:43,720
எனவே, இந்த இரண்டு சரியாக தான் இருக்கும்.

1269
01:18:43,720 --> 01:18:45,840
இது ஒரு விதி சர்க்கரை தான்.

1270
01:18:45,840 --> 01:18:48,090
அவர்கள் அதையே செய்வார்கள். அவர்கள் ஒருவரை ஒருவர் மட்டும் வெவ்வேறு syntactics இருக்கும்.

1271
01:18:51,500 --> 01:18:57,590
>> எனவே, சுட்டிகள் தவறு என்ன போக முடியும்? நிறைய, போன்ற. சரி. எனவே, கெட்ட விஷயங்கள்.

1272
01:18:57,590 --> 01:19:02,410
உங்கள் malloc அழைப்பு பூஜ்ய, சரியான கொடுக்கிறது என்றால் நீங்கள் செய்ய சில கெட்ட விஷயங்களை சரி இல்லை?

1273
01:19:02,410 --> 01:19:06,560
இந்த வழக்கில், நான் என்னிடம் கணினி கேட்கிறேன் - அந்த எண் என்ன?

1274
01:19:06,560 --> 01:19:11,200
ஒரு முழு அளவு 4 பைட்டுகள் ஏனெனில், 2 பில்லியன் மடங்கு 4 போல்.

1275
01:19:11,200 --> 01:19:13,810
நான் 8 பில்லியன் பைட்டுகள் போல் அதை கேட்கிறேன்.

1276
01:19:13,810 --> 01:19:17,270
நிச்சயமாக என் கணினி என்னை மிகவும் நினைவு திரும்ப கொடுக்க முடியும் போவதில்லை.

1277
01:19:17,270 --> 01:19:20,960
இந்த பூஜ்ய என்றால், நாங்கள் அங்கு dereference அதை முயற்சி போது, சோதனை இல்லை -

1278
01:19:20,960 --> 01:19:24,270
அது நடக்கிறது அங்கு அம்பு பின்பற்ற - நாங்கள் அந்த நினைவு இல்லை.

1279
01:19:24,270 --> 01:19:27,150
இந்த ஒரு வெற்று சுட்டிக்காட்டி dereferencing என்போம்.

1280
01:19:27,150 --> 01:19:29,710
இந்த அடிப்படையில் நீங்கள் segfault காரணமாகிறது.

1281
01:19:29,710 --> 01:19:31,790
இந்த segfault வழிகளில் ஒன்றாகும்.

1282
01:19:34,090 --> 01:19:38,090
நீங்கள் என்ன செய்ய முடியும் மற்ற கெட்ட - நல்ல ஓ.

1283
01:19:38,090 --> 01:19:40,650
என்று ஒரு வெற்று சுட்டிக்காட்டி dereferencing. சரி.

1284
01:19:40,650 --> 01:19:45,160
மற்ற கெட்ட விஷயங்கள் - நன்றாக, நீங்கள் அங்கு ஒரு காசோலை வைத்து அதை சரிசெய்ய வேண்டும்

1285
01:19:45,160 --> 01:19:46,980
என்று சுட்டிக்காட்டி பூஜ்ய என்பதை சரிபார்த்து

1286
01:19:46,980 --> 01:19:51,000
அது malloc ஒரு பூஜ்ய சுட்டிக்காட்டி கொடுக்கிறது நடந்தால் மற்றும் நிரல் வெளியே வெளியேறவும்.

1287
01:19:55,110 --> 01:19:59,850
க்ஸ்க்ச்து நகைச்சுவை என்று. மக்கள் இப்போது புரிந்து. இந்த வரிசைப்படுத்த.

1288
01:20:06,120 --> 01:20:09,350
>> எனவே, நினைவக. நான் இந்த வழியாக சென்றார்.

1289
01:20:09,350 --> 01:20:12,000
நாம் ஒரு வட்டத்திற்கு malloc அழைப்பு, ஆனால் நாம் malloc என்று ஒவ்வொரு முறையும்

1290
01:20:12,000 --> 01:20:14,370
நாம், இந்த சுட்டியை சுட்டி காட்டியது அமைந்துள்ள கண்காணிக்கும் வீணாக்கறோம்

1291
01:20:14,370 --> 01:20:15,750
நாம் அது clobbering ஏனெனில்.

1292
01:20:15,750 --> 01:20:18,410
எனவே, malloc ஆரம்ப அழைப்பு என்னை இங்கே நினைவு மேல் கொடுக்கிறது.

1293
01:20:18,410 --> 01:20:19,990
இந்த என் சுட்டிக்காட்டி சுட்டிகள்.

1294
01:20:19,990 --> 01:20:23,020
இப்போது, நான் அதை விடுவிக்க இல்லை, அதனால் இப்போது நான் மீண்டும் malloc அழைப்பு.

1295
01:20:23,020 --> 01:20:26,070
இப்போது இங்கு சுட்டிக்காட்டியுள்ளது. இப்போது என் நினைவு இங்கு சுட்டி.

1296
01:20:26,070 --> 01:20:27,640
இங்கு சுட்டி. இங்கு சுட்டி.

1297
01:20:27,640 --> 01:20:31,820
ஆனால் நான் இங்கே நான் ஒதுக்கப்பட்ட என்று அனைத்து நினைவக முகவரிகளை போனதே.

1298
01:20:31,820 --> 01:20:35,100
அதனால் இப்போது நான் இனி அவர்களுக்கு எந்த குறிப்பும் இல்லை.

1299
01:20:35,100 --> 01:20:37,230
அதனால், நான் இந்த வட்டத்திற்கு வெளியே அவர்களை விடுவிக்க முடியாது.

1300
01:20:37,230 --> 01:20:39,390
எனவே, இந்த மாதிரி ஏதாவது செய்ய வேண்டும்

1301
01:20:39,390 --> 01:20:42,250
நீங்கள் இலவச நினைவக மறந்து நீங்கள் இந்த நினைவக கசிவு கிடைக்கும் என்றால்,

1302
01:20:42,250 --> 01:20:45,810
நீங்கள் முடித்துவிட்டீர்கள் முறை இந்த வட்டத்திற்கு உள்ளே நினைவக விடுவிக்க வேண்டும்.

1303
01:20:45,810 --> 01:20:51,400
சரி, இந்த நடக்கும். நான் உங்களுக்கு நிறைய இந்த வெறுக்கிறேன் என்று.

1304
01:20:51,400 --> 01:20:55,270
ஆனால் இப்போது - ஆஹா! நீங்கள் 44.000 கிலோபைட்டுகளை போல் கிடைக்கும்.

1305
01:20:55,270 --> 01:20:57,110
அதனால், நீங்கள், லூப் இறுதியில் அதை விடுவித்து

1306
01:20:57,110 --> 01:20:59,770
என்று மட்டும் நினைவக ஒவ்வொரு முறையும் விடுவிக்க நடக்கிறது.

1307
01:20:59,770 --> 01:21:03,620
முக்கியமாக, உங்கள் திட்டம் இனி ஒரு நினைவக கசிவு இல்லை.

1308
01:21:03,620 --> 01:21:08,150
>> இப்போது நீங்கள் என்ன செய்ய முடியும் வேறு ஏதாவது நீங்கள் இருமுறை கேட்டு சில நினைவக விடுவித்து உள்ளது.

1309
01:21:08,150 --> 01:21:11,060
இந்த வழக்கில், நீங்கள் malloc ஒன்று, நீங்கள் அதன் மதிப்பை மாற்ற.

1310
01:21:11,060 --> 01:21:13,140
நீங்கள் அதை செய்ய தெரிவித்தார் முறை ஏனெனில் நீங்கள் அதை விடுவிக்க.

1311
01:21:13,140 --> 01:21:14,940
ஆனால் நாம் மீண்டும் விடுதலை.

1312
01:21:14,940 --> 01:21:16,730
இந்த மோசமாக என்று ஒன்று இருக்கிறது.

1313
01:21:16,730 --> 01:21:18,820
இது, ஆரம்பத்தில் segfault போவதில்லை

1314
01:21:18,820 --> 01:21:23,350
ஆனால் ஒரு பின்னர் இந்த இரட்டை இந்த பிழைபடுத்திவிடும் உங்கள் குவியல் அமைப்பு பெறலாம் என்பது என்ன போது,

1315
01:21:23,350 --> 01:21:27,200
நீங்கள் CS61 போன்ற ஒரு வர்க்கம் எடுத்து தேர்வு செய்தால், நீங்கள் இதை பற்றி சிறிது மேலும் அறியலாம்.

1316
01:21:27,200 --> 01:21:30,000
ஆனால் அடிப்படையில் ஒரு பின்னர் உங்கள் கணினியில் குழப்பி போகிறது போது

1317
01:21:30,000 --> 01:21:33,010
- எங்கே, எங்கே சேமிக்கப்பட்டுள்ளது என்ன நினைவக இடங்கள் இருக்கின்றன பற்றி

1318
01:21:33,010 --> 01:21:34,800
அங்கு தரவு நினைவக சேமிக்கப்படுகிறது.

1319
01:21:34,800 --> 01:21:38,080
அதனால் ஒரு சுட்டிக்காட்டி பெறலாம் இரண்டு முறை நீங்கள் செய்ய வேண்டாம் என்று ஒரு கெட்ட விஷயம்.

1320
01:21:38,080 --> 01:21:41,600
>> தவறான செல்ல முடியும் என்று மற்ற விஷயங்களை sizeof பயன்படுத்தி வருகிறது.

1321
01:21:41,600 --> 01:21:44,460
எனவே, இந்த விஷயத்தில் நீங்கள், 8 பைட்டுகள் malloc

1322
01:21:44,460 --> 01:21:46,700
அந்த உரிமை, இரண்டு முழு அதே விஷயம்?

1323
01:21:46,700 --> 01:21:49,580
எனவே, அது செய்தபின் பாதுகாப்பான, ஆனால் என்ன?

1324
01:21:49,580 --> 01:21:52,160
நன்றாக, லூகாஸ், பல்வேறு கட்டமைப்புகளில் பற்றி பேசினார்

1325
01:21:52,160 --> 01:21:54,220
முழு பல்வேறு நீளம் இருக்கும்.

1326
01:21:54,220 --> 01:21:57,970
எனவே, நீங்கள் பயன்படுத்தும் அந்த கருவி மீது, முழு பற்றி 4 பைட்டுகள் ஆகும்

1327
01:21:57,970 --> 01:22:02,370
ஆனால் வேறு சில கணினியில் அவர்கள் 8 பைட்டுகள் இருக்கலாம் அல்லது அவர்கள் 16 பைட்டுகள் இருக்கலாம்.

1328
01:22:02,370 --> 01:22:05,680
அதனால், நான் இங்கு இந்த எண்ணை பயன்படுத்தி,

1329
01:22:05,680 --> 01:22:07,310
இந்த திட்டம், பயன்பாட்டிற்கான வேலை செய்யலாம்

1330
01:22:07,310 --> 01:22:10,360
ஆனால் அது வேறு கணினியில் போதுமான நினைவகம் ஒதுக்க போகவில்லை.

1331
01:22:10,360 --> 01:22:14,020
இந்த வழக்கில், இந்த sizeof ஆபரேட்டர் பயன்படுத்தப்படுகிறது உள்ளது.

1332
01:22:14,020 --> 01:22:16,880
என்ன செய்கிறது என்று நாம் அழைப்பு sizeof (int),

1333
01:22:16,880 --> 01:22:21,910
 அது நம்மை இயங்குவதாக கணினியில் ஒரு முழு அளவு கொடுக்கிறது.

1334
01:22:21,910 --> 01:22:25,490
எனவே, இந்த விஷயத்தில், sizeof (int), பயன்பாடு போன்ற ஏதாவது 4 வரும்

1335
01:22:25,490 --> 01:22:29,980
இப்போது 8 இது இந்த உயில் 4 * 2,,

1336
01:22:29,980 --> 01:22:32,330
இதில் இரண்டு முழு தேவையான இடத்தை அளவு.

1337
01:22:32,330 --> 01:22:36,710
வேறு கணினியில், ஒரு முழு எண்ணாக 16 பைட்டுகள் அல்லது 8 பைட்டுகள் போல் இருந்தால்,

1338
01:22:36,710 --> 01:22:39,380
அது அந்த அளவு சேமிக்க போதுமான பைட்டுகள் திரும்ப நடக்கிறது.

1339
01:22:41,830 --> 01:22:45,310
>> இறுதியாக, structs.

1340
01:22:45,310 --> 01:22:48,340
எனவே, நீங்கள் நினைவகத்தை ஒரு சுடோகுவை குழு சேமிக்க வேண்டும் என்றால், நாங்கள் எப்படி இதை செய்ய முடியும்?

1341
01:22:48,340 --> 01:22:51,570
நீங்கள், முதல் விஷயம் ஒரு மாறி போன்ற நினைக்கலாம்

1342
01:22:51,570 --> 01:22:53,820
இரண்டாவது விஷயம் ஒரு மாறி, மூன்றாவது விஷயம், ஒரு மாறி,

1343
01:22:53,820 --> 01:22:56,420
கெட்ட, வலது - நான்காவது ஒன்று ஒரு மாறி?

1344
01:22:56,420 --> 01:23:00,750
எனவே, இந்த மேல் செய்ய முடியும் ஒரு முன்னேற்றம் 9 x 9 வரிசை செய்ய உள்ளது.

1345
01:23:00,750 --> 01:23:04,480
அது சரி, ஆனால் நீங்கள் சுடோகுவை குழு மற்ற விஷயங்களை சேர்க்க வேண்டும் என்றால்,

1346
01:23:04,480 --> 01:23:06,490
, குழு கஷ்டம் என்ன பிடிக்கும்

1347
01:23:06,490 --> 01:23:11,740
அல்லது, எடுத்துக்காட்டாக, என்ன உங்கள் ஸ்கோர் ஆகும், அல்லது எவ்வளவு நேரம் இந்த பலகையை எடுத்து உள்ளது?

1348
01:23:11,740 --> 01:23:14,970
சரி, நீங்கள் என்ன செய்ய முடியும் நீங்கள் ஒரு struct உருவாக்க முடியும்.

1349
01:23:14,970 --> 01:23:18,910
என்ன நான் அடிப்படையில் சொல்கிறேன், நான் இங்கு இந்த அமைப்பு வரையறை தான் இருக்கிறது

1350
01:23:18,910 --> 01:23:23,230
நான் x 9 9 என்று ஒரு குழு அமைக்கப்பட்டுள்ளது ஒரு சுடோகுவை குழு வரையறுக்கும்.

1351
01:23:23,230 --> 01:23:26,650
>> அதை நிலை பெயர் சுட்டிகளையும் கொண்டுள்ளது என்ன.

1352
01:23:26,650 --> 01:23:30,730
இது நான் இப்போது நான் அங்கு கூறுகள் உள்ளன x மற்றும் y உள்ளது.

1353
01:23:30,730 --> 01:23:35,980
இது நேரம் [புரிந்து] கழித்தார், அது நான் இதுவரை உள்ளிட்ட நான் நகர்வுகள் எண்ணிக்கை உள்ளது.

1354
01:23:35,980 --> 01:23:40,010
எனவே இந்த விஷயத்தில், நான் ஒரு கட்டமைப்பாக தரவு மொத்தமாக குழு முடியாது

1355
01:23:40,010 --> 01:23:42,790
அதற்கு பதிலாக வேறு மாறிகள் போல் சுற்றி பறக்கும் போன்ற தொடங்குவதன்

1356
01:23:42,790 --> 01:23:44,540
நான் டிராக் வைத்திருக்க முடியாது என்று.

1357
01:23:44,540 --> 01:23:49,720
இந்த இந்த struct உள்ளே வேறு விஷயங்களை குறிக்கும் வகை தான் நல்ல தொடரியல் வேண்டும் உதவுகிறது.

1358
01:23:49,720 --> 01:23:53,430
நான் board.board செய்ய மட்டுமே முடியும், மற்றும் நான் திரும்பி சுடோகுவை குழு கிடைக்கும்.

1359
01:23:53,430 --> 01:23:56,320
Board.level, நான் அதை எப்படி கடுமையான கிடைக்கும்.

1360
01:23:56,320 --> 01:24:00,540
Board.x மற்றும் board.y என்னை நான் பலகை இருக்கலாம் எங்கு ஆய கொடுக்க.

1361
01:24:00,540 --> 01:24:04,730
அதனால் நான் struct உள்ள துறைகளில் அழைக்க என்ன அணுகும்.

1362
01:24:04,730 --> 01:24:08,840
இந்த நான் ஒரு வகை இது sudokuBoard, வரையறுக்கிறது.

1363
01:24:08,840 --> 01:24:14,800
இப்போது நாம் இங்கு இருக்கிறோம். நான் வகை sudokuBoard ஒரு "குழு" எனப்படும் ஒரு மாறுபடும் வேண்டும்.

1364
01:24:14,800 --> 01:24:18,820
அதனால் இப்போது நான் இங்கு இந்த கட்டமைப்பை உருவாக்க அனைத்து துறைகளிலும் அணுக முடியும்.

1365
01:24:20,830 --> 01:24:22,450
>> Structs பற்றி எந்த கேள்விகள்? ஆமாம்?

1366
01:24:22,450 --> 01:24:25,890
Int x, y முடிவு [மாணவர்], நீங்கள் ஒரு வரியில் இரண்டு அறிவித்தார்? >> [ஜோசப்] பத்திதான் ம்ம்.

1367
01:24:25,890 --> 01:24:27,400
[மாணவர்] எனவே, நீங்கள் அவர்களை அனைத்து அதை செய்ய முடியும்?

1368
01:24:27,400 --> 01:24:31,200
X போலவே, y மேற்கோள் முறை என்று மொத்த?

1369
01:24:31,200 --> 01:24:34,460
[ஜோசப்] ஆமாம், நீங்கள் நிச்சயமாக நான் ஒரே வரியில் x மற்றும் y வைத்து காரணம் என்று, ஆனால் முடியவில்லை -

1370
01:24:34,460 --> 01:24:36,330
நாங்கள் ஒரே வரிசையில் இதை ஏன் கேள்வி?

1371
01:24:36,330 --> 01:24:38,600
நாம் ஏன் தான் ஒரே வரியில் இந்த அனைத்து போடாதே

1372
01:24:38,600 --> 01:24:42,090
x மற்றும் y ஒன்றுக்கொன்று தொடர்புடையவை,

1373
01:24:42,090 --> 01:24:44,780
இந்த, ஒரு பொருளில், ஒரு stylistically இன்னும் சரியாக

1374
01:24:44,780 --> 01:24:46,600
அதே வரிசையில் இரண்டு விஷயங்கள் குழுக்கள், ஏனெனில்

1375
01:24:46,600 --> 01:24:49,340
என்று போன்ற வகையான அதையே தொடர்பானவை.

1376
01:24:49,340 --> 01:24:51,440
மற்றும் நான் தவிர இந்த பிரிந்தது. இது ஒரு பாணி தான்.

1377
01:24:51,440 --> 01:24:53,720
அது செயல்படவில்லை எந்த வித்தியாசமும் தெரியவில்லை.

1378
01:24:58,150 --> 01:24:59,270
Structs வேறு எந்த கேள்விகள்?

1379
01:25:03,030 --> 01:25:06,620
நீங்கள் ஒரு struct ஒரு Pokédex வரையறுக்க முடியாது.

1380
01:25:06,620 --> 01:25:11,720
ஒரு போகிமொன் ஒரு எண் மற்றும் ஒரு கடிதத்தில், ஒரு உரிமையாளர், ஒரு வகை உண்டு.

1381
01:25:11,720 --> 01:25:16,990
நீங்கள் போகிமொன் ஒரு வரிசை இருந்தால், பின்னர், நீங்கள் சொல்வது சரி, ஒரு Pokédex வரை செய்ய முடியும்?

1382
01:25:16,990 --> 01:25:20,810
சரி, குளிர்ந்த. எனவே, structs கேள்விகள். அந்த structs தொடர்பான இருக்கும்.

1383
01:25:20,810 --> 01:25:25,270
>> இறுதியாக, GDB. GDB நீங்கள் என்ன செய்யலாம்? அதை நீங்கள் உங்கள் நிரல் debug உதவுகிறது.

1384
01:25:25,270 --> 01:25:27,650
நீங்கள் GDB பயன்படுத்தவில்லை எனில், மற்றும், நான் குறுகிய பார்த்து பரிந்துரை

1385
01:25:27,650 --> 01:25:31,250
மற்றும் GDB என்பது என்ன நடக்கிறது, எப்படி, நீங்கள் அதை பயன்படுத்த வேண்டும் என்பதை, அதை வேலை

1386
01:25:31,250 --> 01:25:32,900
மற்றும் ஒரு திட்டத்தை அது சோதிக்க.

1387
01:25:32,900 --> 01:25:37,400
அதனால் GDB நீங்கள் செய்ய முடியும் என்ன இது இடைநிறுத்தம் [புரிந்து] உங்கள் திட்டம் உதவும் என்று

1388
01:25:37,400 --> 01:25:38,920
மற்றும் ஒரு நடைமுறை வரி.

1389
01:25:38,920 --> 01:25:42,600
உதாரணமாக, நான், என் திட்டத்தின் வரி 3 போல் உள்ள இடைநிறுத்தம் மரணதண்டனை வேண்டும்

1390
01:25:42,600 --> 01:25:46,010
நான் வரி 3 இருக்கிறேன் போது நான் உள்ளன என்று அனைத்து மதிப்புகள் அவுட் அச்சிட முடியாது.

1391
01:25:46,010 --> 01:25:49,710
ஒரு வரியில் pausing போன்ற மற்றும் நாம் என்போம்

1392
01:25:49,710 --> 01:25:52,350
நாம் இந்த வரியை ஒரு இடைவேளைநேரத்தை வைத்து அழைப்பு

1393
01:25:52,350 --> 01:25:55,920
பின்னர் நாம் அந்த நேரத்தில் திட்டத்தை மாநில அளவில் மாறிகள் அவுட் அச்சிட முடியாது.

1394
01:25:55,920 --> 01:25:58,990
>> நாம் இருந்து நிரல் வரி மூலம் வரி மூலம் கிடைக்கும் படி.

1395
01:25:58,990 --> 01:26:03,200
மற்றும் நாம் நேரத்தில் ஸ்டாக் மாநில பார்க்க முடியும்.

1396
01:26:03,200 --> 01:26:08,600
அதனால் GDB, நாம் என்ன நாம் சி கோப்பில் கணகண வென்ற சப்தம் அழைப்பு இல்லை, பயன்படுத்த

1397
01:26:08,600 --> 01:26:11,290
ஆனால் நாம் அதை ggdb கொடி அனுப்ப வேண்டும்.

1398
01:26:11,290 --> 01:26:15,850
ஒருமுறை நாங்கள் வெறும் வெளியீடு கோப்பில் gdb ஐ இயக்க என்று முடித்துவிட்டீர்கள்.

1399
01:26:15,850 --> 01:26:18,810
அதனால் நீங்கள், இந்த உரை சில போன்ற வெகுஜன கிடைக்கும்

1400
01:26:18,810 --> 01:26:21,990
ஆனால் நீங்கள் செய்ய வேண்டியது உண்மையில் அனைத்து ஆரம்பத்தில் கட்டளைகளை தட்டச்சு.

1401
01:26:21,990 --> 01:26:24,250
உடைத்து முக்கிய பிரதான ஒரு இடைவேளைநேரத்தை வைக்கிறது.

1402
01:26:24,250 --> 01:26:28,470
பட்டியலில் 400 வரி 400 சுற்றி குறியீடு வரிகளை பட்டியலிடுகிறது.

1403
01:26:28,470 --> 01:26:31,410
எனவே இந்த விஷயத்தில் நீங்கள் தான், ஓ, சுற்றி பார்த்து சொல்ல முடியும்

1404
01:26:31,410 --> 01:26:34,360
நான் இந்த வரி என்பது வரி 397 ஒரு இடைவேளைநேரத்தை, அமைக்க வேண்டும்

1405
01:26:34,360 --> 01:26:37,170
பின்னர் உங்கள் திட்டம் என்று நடவடிக்கை மூலம் இயங்கும் மற்றும் அதை உடைக்க நடக்கிறது.

1406
01:26:37,170 --> 01:26:41,120
அங்கு இடைநிறுத்தப்பட்டு நடக்கிறது, நீங்கள், எடுத்துக்காட்டாக, குறைந்த அல்லது உயர்ந்த மதிப்பு அவுட் அச்சிட முடியாது.

1407
01:26:41,120 --> 01:26:46,410
அதனால் நீங்கள் தெரிந்து கொள்ள வேண்டும் கட்டளைகளை ஒரு கொத்து உள்ளன

1408
01:26:46,410 --> 01:26:48,660
இந்த காட்சியை, வலைத்தளத்தில் வரை போயும்

1409
01:26:48,660 --> 01:26:54,000
நீங்கள் இந்த குறிக்க வேண்டும் அல்லது உங்கள் ஏமாற்று தாள்கள் மீது வைக்கவும் போல் நீங்கள், எனக்கு.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. என்று வினா விமர்சனம் 0 இருந்தது, நீங்கள் ஏதாவது கேள்விகள் இருந்தால், நாங்கள் சுற்றி உறுதியாக சொல்கிறேன்.

1411
01:27:00,650 --> 01:27:03,850
எல்லாம் சரி.

1412
01:27:03,850 --> 01:27:09,030
>>  [கரவொலி]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]