1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [విభాగం 4] [తక్కువ సౌకర్యవంతమైన]

2
00:00:02,000 --> 00:00:04,000
[నేట్ Hardison] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,000 --> 00:00:07,000
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> All right, విభాగం తిరిగి స్వాగతం.

5
00:00:10,000 --> 00:00:13,000
ఈ వారం యొక్క విభాగంలో మేము కొన్ని విషయాలను చేయబోతున్నామని.

6
00:00:13,000 --> 00:00:17,000
మేము, మొదటి రీక్యాప్ సమస్య సెట్ 2 చూడాలని

7
00:00:17,000 --> 00:00:20,000
సీజర్ మరియు విజెనెరే సమస్య సెట్ ఇది.

8
00:00:20,000 --> 00:00:23,000
మరియు తర్వాత మేము క్విజ్ 0 సమీక్ష ప్రవేశిస్తాడు చూడాలని

9
00:00:23,000 --> 00:00:26,000
మరియు మేము గురించి మాట్లాడారు వాటిని recapping సమయం కొద్దిగా ఖర్చు

10
00:00:26,000 --> 00:00:30,000
ప్రసంగాలను ప్రతి ఇప్పటివరకు, మరియు మేము కూడా కొన్ని సమస్యలు చేస్తాను

11
00:00:30,000 --> 00:00:32,000
గత సంవత్సరం క్విజ్ నుండి.

12
00:00:32,000 --> 00:00:36,000
మీరు అబ్బాయిలు ఆ సిద్ధం ఒక మంచి మార్గం కలిగి మార్గం.

13
00:00:36,000 --> 00:00:40,000
>> ప్రారంభించడానికి, నేను మంచి పరిష్కారాలు ఒక జంట అప్ బూట్ చేసిన

14
00:00:40,000 --> 00:00:45,000
మునుపటి సమస్య కోసం, సమస్య ఈ అంతరిక్షంలోకి, 2 సెట్.

15
00:00:45,000 --> 00:00:48,000
మీరు అబ్బాయిలు ఈ లింక్ నొక్కండి, ఉంటే

16
00:00:48,000 --> 00:00:53,000
మరియు మీరు నా పేరు క్లిక్ చేయండి మరియు నా మొదటి పునర్విమర్శ క్లిక్ ఉంటే

17
00:00:53,000 --> 00:00:56,000
మీరు నేను వద్ద చూస్తున్నాను వేటి ఇది caesar.c, చూస్తారు.

18
00:00:56,000 --> 00:01:00,000
యొక్క నిజంగా త్వరగా ఈ మాట్లాడటానికి లెట్.

19
00:01:00,000 --> 00:01:02,000
ఇది ఒక నమూనా పరిష్కారం.

20
00:01:02,000 --> 00:01:05,000
ఈ ఖచ్చితమైన పరిష్కారం అవసరం లేదు.

21
00:01:05,000 --> 00:01:08,000
ఈ వ్రాయడానికి అనేక మార్గాలు ఉన్నాయి

22
00:01:08,000 --> 00:01:10,000
కానీ నేను హైలైట్ కోరుకున్నాడు కొన్ని విషయాలను

23
00:01:10,000 --> 00:01:13,000
నేను అనుకుంటున్నాను నేను శ్రేణి గా చూసిన, సాధారణ తప్పులను

24
00:01:13,000 --> 00:01:18,000
ఈ పరిష్కారం నిర్వహణ ఒక మంచి ఉద్యోగం చేస్తుంది.

25
00:01:18,000 --> 00:01:22,000
>> మొదటి ఎగువన శీర్షిక వ్యాఖ్య విధమైన గురైంది.

26
00:01:22,000 --> 00:01:25,000
లైన్లు 1 న 7 ద్వారా మీరు, వివరాలను చూడండి

27
00:01:25,000 --> 00:01:28,000
ఈ కార్యక్రమం ఖచ్చితంగా ఏమి ఉంది.

28
00:01:28,000 --> 00:01:32,000
మీరు C కోడ్ వ్రాస్తున్నప్పుడు మంచి ప్రామాణిక పద్ధతి

29
00:01:32,000 --> 00:01:35,000
మీ ప్రోగ్రామ్ ఒక ఫైల్ లేదా లోపల ఉంది సంబంధం లేకుండా ఉంటే

30
00:01:35,000 --> 00:01:38,000
ఇది బహుళ ఫైళ్లను మీద విభజించబడింది అయినా విధమైన కలిగి ఉంది

31
00:01:38,000 --> 00:01:40,000
ఎగువన వ్యాఖ్య ఓరియంటింగ్.

32
00:01:40,000 --> 00:01:43,000
ఈ బయటకు వెళ్లి వాస్తవ ప్రపంచంలో కోడ్ రాసే వ్యక్తులు కూడా ఉంది.

33
00:01:43,000 --> 00:01:47,000
వారు కాపీరైట్ సమాచారం ఉంచుతాము ఇది ఉంది.

34
00:01:47,000 --> 00:01:50,000
క్రింద # కలిగి ఉంటాయి.

35
00:01:50,000 --> 00:01:55,000
లైన్ 16 న ఈ # మేము ఒక బిట్ లో తిరిగి వచ్చి మేము, నిర్వచించే ఉంది.

36
00:01:55,000 --> 00:01:59,000
మరియు తర్వాత ఒకసారి ఫంక్షన్, ఒకసారి ప్రధాన ప్రారంభాల్లో మొదలవుతుంది

37
00:01:59,000 --> 00:02:03,000
ఈ కార్యక్రమం అన్ని ఒకే ఫంక్షన్ లో కలిగి ఎందుకంటే

38
00:02:03,000 --> 00:02:09,000
జరిగినప్పుడు పైన మరియు ఇది చాలా idiomatic మరియు ఒక సి కార్యక్రమం సాధారణ చాలా మొదటి విషయం

39
00:02:09,000 --> 00:02:14,000
కమాండ్ లైన్ లో పడుతుంది అది వెంటనే తనిఖీ ఆ వాదనలు-ఉంది

40
00:02:14,000 --> 00:02:18,000
>> వాదన లెక్కింపు కోసం, argc.

41
00:02:18,000 --> 00:02:24,000
ఇక్కడే మేము ఈ కార్యక్రమం ఖచ్చితంగా 2 వాదనలు ఆశిస్తున్న ఆ చూడండి.

42
00:02:24,000 --> 00:02:27,000
గుర్తుంచుకోండి ప్రత్యేక ఒకటి మొదటి వాదన ఉంది

43
00:02:27,000 --> 00:02:29,000
ఆ, ఎల్లప్పుడూ అమలు చేయబడిన ప్రోగ్రామ్ యొక్క పేరు ఉంది

44
00:02:29,000 --> 00:02:31,000
ఎక్జిక్యూటబుల్ ఫైల్ యొక్క పేరు.

45
00:02:31,000 --> 00:02:36,000
కాబట్టి ఈ ఏమి ఈ కార్యక్రమం అమలు నుండి వినియోగదారు నిరోధిస్తుంది

46
00:02:36,000 --> 00:02:42,000
ఎక్కువ లేదా తక్కువ వాదనలు తో.

47
00:02:42,000 --> 00:02:44,000
మేము దూరంగా ఈ హక్కు కోసం తనిఖీ మీరు కారణం ఉంది

48
00:02:44,000 --> 00:02:52,000
మేము నిజంగా ఇక్కడే విశ్వసనీయంగా ఈ argv శ్రేణి యాక్సెస్ చేయలేరు

49
00:02:52,000 --> 00:02:55,000
మేము ఎంత పెద్ద చూడటానికి తనిఖీ చేసిన వరకు.

50
00:02:55,000 --> 00:02:58,000
>> నేను చూసిన సాధారణ లోపాలు వ్యక్తుల వెంటనే లో పాటు ఉంది

51
00:02:58,000 --> 00:03:01,000
మరియు తీసుకున్న argv [1].

52
00:03:01,000 --> 00:03:06,000
అవి శ్రేణి యొక్క కీ వాదన పట్టుకొను భావిస్తున్న మరియు ఒక నేను, దానిపై తనిఖీ లేదు

53
00:03:06,000 --> 00:03:11,000
మరియు తర్వాత వారు, అదే తరువాత పరీక్ష వంటి argc కోసం పరీక్ష చేయండి భావిస్తున్న

54
00:03:11,000 --> 00:03:16,000
మొదటి వాదన నిజానికి అదే సమయంలో పూర్ణాంకం ఉంది, లేదో

55
00:03:16,000 --> 00:03:20,000
మరియు ఆ సరఫరా ఏ వాదనలు ఉన్నాయి ఆ సందర్భంలో ఎందుకంటే పని లేదు

56
00:03:20,000 --> 00:03:26,000
మీరు అక్కడ లేని వాదన పట్టుకుని లేదా లేదు ఒక పట్టుకొను ప్రయత్నం చేస్తాము.

57
00:03:26,000 --> 00:03:29,000
>> మీరు గమనించే అని ఇతర పెద్ద విషయం అని

58
00:03:29,000 --> 00:03:32,000
మీరు ఎల్లప్పుడూ ఉపయోగపడిందా దోష సందేశం విధమైన ముద్రించాలా కావలసిన

59
00:03:32,000 --> 00:03:34,000
ఓరియంట్ వారికి వినియోగదారుకు.

60
00:03:34,000 --> 00:03:37,000
నేను, మీరు ఆకస్మికంగా అది కూలిపోతుంది అన్ని పరుగుల కార్యక్రమాలు చేసారని ఉన్నాను

61
00:03:37,000 --> 00:03:41,000
మరియు మీరు బయటకు మరియు అని ఈ హాస్యాస్పదంగా చిన్న డైలాగ్ పొందండి

62
00:03:41,000 --> 00:03:44,000
బహుశా భయంకరమైన నిగూఢ మరియు ఏదో ఒక లోపం కోడ్ లేదా అలాంటిదే ఇస్తుంది

63
00:03:44,000 --> 00:03:47,000
ఆ అస్సలు అర్ధమే లేదు.

64
00:03:47,000 --> 00:03:50,000
మీరు నిజంగా ఉపయోగపడిందా ఏదో అందించే చోట ఈ ఉంది

65
00:03:50,000 --> 00:03:54,000
మరియు వారు అమలు చేసినప్పుడు వారు "ఓహ్," ముఖం తాటి వెళ్ళి కాబట్టి యూజర్ లక్ష్యంగా.

66
00:03:54,000 --> 00:03:58,000
"నేను ఖచ్చితంగా తెలుసు. నేను ఈ ఎలా పరిష్కరించాలో తెలుసు."

67
00:03:58,000 --> 00:04:01,000
>> మీరు ఒక సందేశాన్ని ప్రింట్ లేదు, అప్పుడు మీరు నిజంగా ముగుస్తుంది

68
00:04:01,000 --> 00:04:04,000
యూజర్ వెళ్ళడానికి వదిలి మీ సోర్స్ కోడ్ పరిశీలించడానికి

69
00:04:04,000 --> 00:04:07,000
వాట్ వెంట్ రాంగ్ గుర్తించడానికి.

70
00:04:07,000 --> 00:04:11,000
మీరు వివిధ లోపం సంకేతాలు ఉపయోగిస్తారు కొన్ని సార్లు కూడా ఉన్నాయి.

71
00:04:11,000 --> 00:04:14,000
ఇక్కడ మనం కేవలం ఒక లోపం ఉంది చెప్పడానికి ఒక ఉపయోగిస్తారు

72
00:04:14,000 --> 00:04:16,000
ఒక లోపం ఉంది, ఒక లోపం ఉంది.

73
00:04:16,000 --> 00:04:20,000
పెద్ద కార్యక్రమాలను, ఇతర కార్యక్రమాల ద్వారా పిలుస్తారు తరచుగా కార్యక్రమాలు

74
00:04:20,000 --> 00:04:25,000
వివిధ పరిస్థితులలో ప్రత్యేక లోపం సంకేతాలు విధమైన తిరిగి

75
00:04:25,000 --> 00:04:28,000
programmatically కమ్యూనికేట్ చేయడానికి మీరు లేకపోతే ఆ

76
00:04:28,000 --> 00:04:32,000
కేవలం ఒక nice ఇంగ్లీష్ సందేశాన్ని ఉపయోగించండి.

77
00:04:32,000 --> 00:04:35,000
కూల్.

78
00:04:35,000 --> 00:04:37,000
మేము డౌన్ పని, మీరు మేము కీ వెలికితీసి చూడగలరు.

79
00:04:37,000 --> 00:04:40,000
మేము కీ సరిపోయే చూడండి పరీక్ష.

80
00:04:40,000 --> 00:04:42,000
మేము వినియోగదారు నుండి ఒక సందేశాన్ని.

81
00:04:42,000 --> 00:04:46,000
ఈ మేము కవర్ ఏదైనా పైన మరియు లూప్ ఉంది మేము ఈ లో దీనిని కారణం చేయండి

82
00:04:46,000 --> 00:04:50,000
కొద్దిగా బిట్-కానీ అవుతుంది మీరు కంట్రోల్ D టైప్ ఉంటే

83
00:04:50,000 --> 00:04:54,000
మీరు టెర్మినల్ ఆ GetString ప్రాంప్ట్ వచ్చినప్పుడు

84
00:04:54,000 --> 00:04:59,000
నిజానికి చేసే దానిని ఒక ప్రత్యేక పాత్ర ఉంది పంపుతుంది

85
00:04:59,000 --> 00:05:01,000
కార్యక్రమానికి.

86
00:05:01,000 --> 00:05:05,000
ఇది ELF లేదా ఫైల్ పాత్ర ముగింపు అని.

87
00:05:05,000 --> 00:05:08,000
ఆ సందర్భంలో, మా సందేశం స్ట్రింగ్, శూన్య ఉంటుంది

88
00:05:08,000 --> 00:05:14,000
ఈ మేము కూడా సెట్ సమస్య లో పరీక్షలు ఏదో కాదు.

89
00:05:14,000 --> 00:05:17,000
>> మేము వెళ్ళి కానీ, ఇప్పుడు మేము గమనికలు మాట్లాడటానికి ప్రారంభించారు చేసిన

90
00:05:17,000 --> 00:05:21,000
కుప్ప మీద మరియు డైనమిక్ మెమరీ కేటాయింపు,

91
00:05:21,000 --> 00:05:25,000
మీరు ఆ వాటిని ఒక ఫంక్షన్ ఉన్నప్పుడు శూన్య తనిఖీ

92
00:05:25,000 --> 00:05:30,000
ఒక విలువ మీరు చేస్తున్న అలవాటు పొందాలనుకోవడం మేము ఏదో ఉంది శూన్య తిరిగి.

93
00:05:30,000 --> 00:05:33,000
ఈ ప్రధానంగా ఉదాహరణ కోసం ఇక్కడ ఉంది.

94
00:05:33,000 --> 00:05:36,000
కానీ మీరు భవిష్యత్తులో GetString చూడండి చేసినప్పుడు,

95
00:05:36,000 --> 00:05:41,000
అలా 4 సెట్ సమస్య నుండి, మీరు ఈ విషయాన్ని మనస్సులో ఉంచుకోవాలి చెయ్యవచ్చును.

96
00:05:41,000 --> 00:05:44,000
మళ్ళీ, ఈ మేము ఇంకా అది కవర్ కాదు నుండి గాని 3 సెట్ సమస్య కోసం ఒక సమస్య కాదు.

97
00:05:44,000 --> 00:05:53,000
చివరగా, మేము, మేము ప్రధాన ఎన్క్రిప్షన్ లూప్ ను పేరు ఈ భాగం ను

98
00:05:53,000 --> 00:05:57,000
మరియు ఇక్కడ జరగబోతోంది కొన్ని విషయాలను ఉన్నాయి.

99
00:05:57,000 --> 00:06:02,000
మొదటి, మేము మొత్తం సందేశం స్ట్రింగ్ దానిపై అదే iterate.

100
00:06:02,000 --> 00:06:07,000
ఇక్కడ మేము, పరిస్థితిలో strlen కాల్ ఉంచింది చేసిన

101
00:06:07,000 --> 00:06:12,000
మీరు అనేక చెప్తారు వెళ్ళి ఒక గొప్ప మార్గం లేదు.

102
00:06:12,000 --> 00:06:15,000
ఇది కూడా గొప్ప కాదు ఈ సందర్భంలో అవుతుంది

103
00:06:15,000 --> 00:06:20,000
మేము సందేశాన్ని యొక్క సమాచారాలను మార్చడం చేస్తున్నారు కారణం

104
00:06:20,000 --> 00:06:27,000
లోపల లూప్, కాబట్టి మేము 10 అక్షరాల పొడవు ఉన్న ఒక సందేశాన్ని ఉంటే,

105
00:06:27,000 --> 00:06:32,000
మొదటిసారి మేము లూప్ strlen కోసం ఏమి తిరిగి ఆ ప్రారంభం?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> కానీ మేము అప్పుడు సందేశాన్ని మార్చడానికి ఉంటే, మేము దాని 5 వ పాత్ర సవరించడానికి సే

108
00:06:40,000 --> 00:06:46,000
మరియు మేము, 5 వ స్థానంలో \ 0 పాత్ర విసరాలి

109
00:06:46,000 --> 00:06:49,000
తరువాత మళ్ళా న strlen (సందేశం) అది ఏమి తిరిగి కనిపిస్తుంది

110
00:06:49,000 --> 00:06:52,000
మేము iterated మొదటిసారిగా,

111
00:06:52,000 --> 00:06:56,000
మేము ఆ శూన్య టెర్మినేటర్ విసిరిన ఎందుకంటే కానీ బదులుగా, 5 చూపిస్తుంది

112
00:06:56,000 --> 00:06:59,000
మరియు స్ట్రింగ్ యొక్క పొడవు నిర్వచిస్తారు

113
00:06:59,000 --> 00:07:03,000
ఆ \ 0 యొక్క స్థానం.

114
00:07:03,000 --> 00:07:09,000
ఈ సందర్భంలో, ఈ మేము స్థానంలో దానిని సరిచేయడం ఉన్నందున వెళ్ళడానికి గొప్ప మార్గం.

115
00:07:09,000 --> 00:07:13,000
కానీ మీరు ఈ గుప్తీకరించడానికి వాస్తవానికి ఆశ్చర్యకరంగా సాధారణ గమనించి

116
00:07:13,000 --> 00:07:16,000
మీరు గణిత సరైన లభిస్తే.

117
00:07:16,000 --> 00:07:19,000
అవసరం అయిన అన్ని మీరు శోధిస్తున్న లేదో లేఖ తనిఖీ చేయడం

118
00:07:19,000 --> 00:07:21,000
పెద్ద లేదా చిన్న ఉంది.

119
00:07:21,000 --> 00:07:24,000
>> మేము ఆ తనిఖీ చేసి మేము తనిఖీ లేదు కారణం

120
00:07:24,000 --> 00:07:27,000
ఉంది ఆల్ఫా కేసు ఎందుకంటే ఉంది

121
00:07:27,000 --> 00:07:30,000
ఒక పాత్ర పెద్ద లేదా ఉంటే అది చిన్న యొక్క

122
00:07:30,000 --> 00:07:33,000
అప్పుడు, ఖచ్చితంగా అక్షరమాల పాత్ర

123
00:07:33,000 --> 00:07:38,000
మేము పెద్ద మరియు చిన్న అంకెలు లేదు ఎందుకంటే.

124
00:07:38,000 --> 00:07:41,000
మేము పైన మరియు ఇతర విషయం ఈ చిన్న ఉంది గమ్మత్తైన-

125
00:07:41,000 --> 00:07:45,000
మేము ప్రామాణిక సీజర్ సాంకేతికలిపి ఫార్ములా చివరి మార్పు చేసిన ఉంది

126
00:07:45,000 --> 00:07:49,000
మేము సమస్య సెట్ వివరణలో ఇచ్చిన.

127
00:07:49,000 --> 00:07:52,000
ఇక్కడికి విభిన్నమైనది మేము తీసివేయటం ఉంది

128
00:07:52,000 --> 00:07:58,000
పెద్ద కేసు రాజధాని లో, మరియు మేము ఒక రాజధాని జోడించారు

129
00:07:58,000 --> 00:08:02,000
చివరిలో తిరిగి.

130
00:08:02,000 --> 00:08:05,000
>> నేను మీరు కొన్ని మీ కోడ్ ఈ బాధ్యతను తెలుసు.

131
00:08:05,000 --> 00:08:09,000
మీరు ఏ మీ సమర్పణలు ఈ చేస్తారు?

132
00:08:09,000 --> 00:08:13,000
మీరు ఈ చేశాడు. మీరు, ఈ ఏమి Sahb వివరిస్తుంది?

133
00:08:13,000 --> 00:08:18,000
మీరు కుడి అది తర్వాత ఒక mod ఎందుకంటే, దాన్ని తీసివేయడం ద్వారా,

134
00:08:18,000 --> 00:08:21,000
మీరు, మీరు స్థానం [దగ్గు] పొందండి అందువలన దానిని తీసుకోవాలని.

135
00:08:21,000 --> 00:08:25,000
తరువాత తిరిగి జోడించడం ద్వారా మీరు నాకు పైగా మారింది.

136
00:08:25,000 --> 00:08:27,000
అవును, సరిగ్గా.

137
00:08:27,000 --> 00:08:32,000
Sahb చెప్పాడు దాని మేము జోడించడానికి ఉంటుంది

138
00:08:32,000 --> 00:08:36,000
మా సందేశం మరియు కలిసి మా కీ

139
00:08:36,000 --> 00:08:42,000
ఆపై mod, ఆ mod ఆ NUM_LETTERS ద్వారా,

140
00:08:42,000 --> 00:08:50,000
మేము మొదటి తగిన 0 to 25 శ్రేణి లోకి మా సందేశం స్కేల్ లేకపోతే,

141
00:08:50,000 --> 00:08:54,000
అప్పుడు మేము ఒక నిజంగా అసాధారణ సంఖ్య పొందడానికి ముగుస్తుంది ఉండవచ్చు

142
00:08:54,000 --> 00:08:59,000
ఎందుకంటే మేము సందేశాన్ని [i] చూస్తున్నప్పుడు శోధిస్తున్న విలువలు,

143
00:08:59,000 --> 00:09:03,000
మేము మా సాదా టెక్స్ట్ సందేశం యొక్క ith పాత్ర చూస్తున్నప్పుడు,

144
00:09:03,000 --> 00:09:08,000
ఒక విలువ ఈ 65 వరకు 122 పరిధిలో ఎక్కడో ఉంది

145
00:09:08,000 --> 00:09:13,000
చిన్న z ద్వారా పెద్ద A కోసం ASCII విలువలు ఆధారంగా.

146
00:09:13,000 --> 00:09:18,000
కాబట్టి మేము, 26 లేదా NUM_LETTERS ద్వారా MoD ఉన్నప్పుడు

147
00:09:18,000 --> 00:09:23,000
ఆ తర్వాత మా # అప్ ఇక్కడ కుడి ఎగువ నిర్వచించే,

148
00:09:23,000 --> 00:09:28,000
మాకు 0 to 25 పరిధిలో ఉన్న ఒక విలువ ఇవ్వడం అవకాశముంది,

149
00:09:28,000 --> 00:09:30,000
మరియు మేము ఆ తిరిగి అప్ స్కేల్ ఒక మార్గం అవసరం

150
00:09:30,000 --> 00:09:32,000
మరియు అది సరైన ASCII పరిధిలో పొందండి.

151
00:09:32,000 --> 00:09:36,000
అలా సులభమైన మార్గం కేవలం ప్రతిదీ డౌన్ స్థాయికి ఉంది

152
00:09:36,000 --> 00:09:39,000
0 to 25 శ్రేణి లోకి తో ప్రారంభించడానికి

153
00:09:39,000 --> 00:09:43,000
తరువాత చివరిలో తిరిగి ప్రతిదీ పైకి తీసుకెళ్లడం.

154
00:09:43,000 --> 00:09:46,000
>> నేను ప్రజలు ఆకస్మికంగా చూసిన మరో సాధారణ లోపం ఉంది

155
00:09:46,000 --> 00:09:50,000
మీరు నిజంగా వెంటనే ఈ స్కేలింగ్ చేయకపోతే

156
00:09:50,000 --> 00:09:53,000
మరియు, సే, మీరు కలిసి సందేశాన్ని కీ జోడించడానికి మరియు మీరు వాటిని జోడించండి

157
00:09:53,000 --> 00:09:58,000
ఆ తో చార్ వేరియబుల్ లోకి, సమస్య

158
00:09:58,000 --> 00:10:01,000
ఉంది సందేశం నుండి [i] ప్రారంభించడానికి చాలా పెద్ద సంఖ్య తో

159
00:10:01,000 --> 00:10:05,000
అది ఒక పెద్ద అయితే అది కనీసం 65 యొక్క గుర్తు పాత్ర

160
00:10:05,000 --> 00:10:09,000
మీరు ఒక పెద్ద కీ, చెప్పడానికి, 100 వంటి ఏదైనా కలిగి ఉంటే

161
00:10:09,000 --> 00:10:13,000
మరియు మీరు ఒక ఓవర్ఫ్లో పొందడానికి వెళుతున్న ఒక సంతకం చార్ కలిపి ఆ 2 జోడించండి.

162
00:10:13,000 --> 00:10:17,000
మీరు, 127 కంటే పెద్ద ఉన్న ఒక విలువ పొందడానికి వెళుతున్న

163
00:10:17,000 --> 00:10:22,000
ఒక చార్ వేరియబుల్ కలిగి ఆ పెద్ద విలువ.

164
00:10:22,000 --> 00:10:26,000
మీరు ప్రారంభించడానికి విషయం ఆ విధమైన చేయాలనుకుంటున్నారా మీరు ఎందుకు తిరిగి, ఆ.

165
00:10:26,000 --> 00:10:29,000
కొంతమంది ఒక ఉంటే ఇంకా చేయడం మరియు పరీక్షించడం ద్వారా ఆ కేసు అధిగమించింది

166
00:10:29,000 --> 00:10:33,000
అది ఓవర్ఫ్లో అని ఆ చేసే ముందు చూడటానికి,

167
00:10:33,000 --> 00:10:36,000
కానీ ఈ విధంగా చుట్టూ పొందుతాడు.

168
00:10:36,000 --> 00:10:40,000
మరియు ఈ ద్రావణంలో మేము చాలా చివరలో మొత్తం స్ట్రింగ్ ముద్రించిన.

169
00:10:40,000 --> 00:10:45,000
ఇతర ప్రజలు ఒక సమయంలో ఒక పాత్ర ముద్రించిన. రెండు అద్భుతమైన ఉంటాయి.

170
00:10:45,000 --> 00:10:51,000
ఈ సమయంలో,, మీరు అబ్బాయిలు ఏవైనా ప్రశ్నలు ఈ గురించి ఎటువంటి వ్యాఖ్యలు ఏమి?

171
00:10:51,000 --> 00:10:56,000
మీరు వంటి వాటిని, మీకు నచ్చని విషయాలు?

172
00:10:56,000 --> 00:10:58,000
>> నేను ఒక ప్రశ్న ఉంది.

173
00:10:58,000 --> 00:11:01,000
బహుశా నేను మీ వివరణ సమయంలో అది ఆడలేకపోయాడు, కానీ ఈ కార్యక్రమం ఎలా

174
00:11:01,000 --> 00:11:07,000
టెక్స్ట్ యొక్క పొడవు కీ కనెక్ట్ ప్రాంతాలను skip?

175
00:11:07,000 --> 00:11:10,000
ఇది సీజర్ సాంకేతికలిపి. >> ఓహ్, సారీ, అవును.

176
00:11:10,000 --> 00:11:13,000
అవును, మేము ఆ చూస్తారు.

177
00:11:13,000 --> 00:11:16,000
సీజర్ సాంకేతికలిపి లో మేము ఆ చుట్టూ కాబట్టి

178
00:11:16,000 --> 00:11:18,000
మేము మాత్రమే అక్షరాలు ఒరిగిందని.

179
00:11:18,000 --> 00:11:27,000
వారు పెద్ద లేదా చిన్న ఉన్నామనుకుంటే వారికి మాత్రమే తిరుగుతుంది.

180
00:11:27,000 --> 00:11:32,000
మీరు అబ్బాయిలు ఈ గురించి చాలా ఫీలింగ్ గుడ్?

181
00:11:32,000 --> 00:11:34,000
ఈ హోమ్ కాపీ సంకోచించకండి, తీసుకెళ్ళవచ్చు

182
00:11:34,000 --> 00:11:37,000
మీరు అబ్బాయిలు రాశారు దానిని పోల్చి.

183
00:11:37,000 --> 00:11:42,000
ఖచ్చితంగా చాలా దాని గురించి ప్రశ్నలు పంపడానికి సంకోచించకండి.

184
00:11:42,000 --> 00:11:46,000
మరోసారి, మీ సమస్య ఇక్కడ గోల్ సెట్ చేసే తెలుసుకుంటారు

185
00:11:46,000 --> 00:11:50,000
మీరు అబ్బాయిలు మీ సమస్య సెట్లు సరైన కోడ్ వ్రాయడానికి పొందడానికి కాదు.

186
00:11:50,000 --> 00:11:57,000
ఇది ఒక అభ్యాస అనుభవం. అవును.

187
00:11:57,000 --> 00:12:01,000
>> తిరిగి చేయుటకు లూప్, అది సమానం ఉంటే శూన్య అయితే,

188
00:12:01,000 --> 00:12:06,000
కాబట్టి శూన్య కేవలం ఏమీ అర్థం, అవి కేవలం ఎంటర్ నొక్కండి?

189
00:12:06,000 --> 00:12:12,000
నల్, ఒక ప్రత్యేక పాయింటర్ విలువ

190
00:12:12,000 --> 00:12:17,000
మేము చెప్పే ఉంటుంది మరియు మేము శూన్య ఉపయోగించడానికి

191
00:12:17,000 --> 00:12:23,000
మేము ఏమీ సూచించే ఒక పాయింటర్ వేరియబుల్ ఉన్నాయి.

192
00:12:23,000 --> 00:12:28,000
కనుక అవి అది అర్థం ఈ వేరియబుల్, ఈ సందేశాన్ని వేరియబుల్

193
00:12:28,000 --> 00:12:35,000
మేము CS50 ప్రత్యేక స్ట్రింగ్ రకం ఉపయోగించే ఎందుకంటే, ఖాళీ, మరియు ఇక్కడ ఉంది,

194
00:12:35,000 --> 00:12:37,000
CS50 స్ట్రింగ్ ఏ రకం?

195
00:12:37,000 --> 00:12:42,000
మీరు డేవిడ్ ఉపన్యాసంలో హుడ్ వెనక్కు ఉన్నప్పుడు ఏమి చూసిన?

196
00:12:42,000 --> 00:12:44,000
ఇది ఒక అల్లరిగా-అంతే ఒక పాయింటర్ ఉంది, కుడి?

197
00:12:44,000 --> 00:12:48,000
సరే, అవును. >> ఇది ఒక చార్ * ఉంది.

198
00:12:48,000 --> 00:12:52,000
కాబట్టి మేము ఈ భర్తీ

199
00:12:52,000 --> 00:12:56,000
ఇక్కడే చార్ * సందేశం,

200
00:12:56,000 --> 00:13:04,000
అందువలన GetString ఫంక్షన్, ఇది విజయవంతంగా వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందుటకు లేదు ఉంటే,

201
00:13:04,000 --> 00:13:08,000
అది ఒక స్ట్రింగ్ అన్వయించడం సాధ్యం కాదు, మరియు ఒక సందర్భంలో ఇది ఒక స్ట్రింగ్ అన్వయించడం సాధ్యం కాదు

202
00:13:08,000 --> 00:13:11,000
వినియోగదారుడికి రకాల ఫైల్ పాత్ర, నియంత్రణ D, ముగింపు ఉంటే

203
00:13:11,000 --> 00:13:17,000
మీరు సాధారణంగా వాటి కాదు, కానీ జరుగుతుందని ఉంటే

204
00:13:17,000 --> 00:13:20,000
అప్పుడు ఫంక్షన్ చెప్పడం ఒక మార్గంగా ఈ శూన్య విలువను తిరిగి

205
00:13:20,000 --> 00:13:23,000
"హే, నేను ఒక స్ట్రింగ్ రాలేదు."

206
00:13:23,000 --> 00:13:27,000
మేము సందేశాన్ని = శూన్య ఉంచవద్దు ఏమి, జరుగుతుంది

207
00:13:27,000 --> 00:13:30,000
మేము ఇంకా చేయడం కాలేదు ఏదో ఇది?

208
00:13:30,000 --> 00:13:32,000
ఎందుకు ఇక్కడ ఒక సమస్య ఉంటుంది?

209
00:13:32,000 --> 00:13:38,000
మనం మెమరీ లీకేజ్ గురించి ఉపన్యాసంలో కొద్దిగా మాట్లాడారు తెలుసు ఎందుకంటే.

210
00:13:38,000 --> 00:13:42,000
అవును, అలా చేసుకుందాం, మరియు ఏమి చూడండి లెట్స్.

211
00:13:42,000 --> 00:13:44,000
>> బాసిల్ యొక్క ప్రశ్న మేము నిజానికి లేదు ఏమవుతుంది ఉంది

212
00:13:44,000 --> 00:13:48,000
ఈ సందేశం = శూన్య పరీక్ష?

213
00:13:48,000 --> 00:13:51,000
టాప్ వరకు స్క్రోల్ లెట్ యొక్క.

214
00:13:51,000 --> 00:13:53,000
మీరు అబ్బాయిలు ఇది వ్యాఖ్యానించగలరు.

215
00:13:53,000 --> 00:13:55,000
అసలైన, నేను ఒక పునర్విమర్శ లో సేవ్ చేస్తాము.

216
00:13:55,000 --> 00:13:58,000
ఈ కూర్పుల 3 ఉంటుంది.

217
00:13:58,000 --> 00:14:02,000
ఏం మీరు ఈ ప్రోగ్రామ్ను అమలు చేయడానికి ఏమి ఉంటుంది, మీరు ఇక్కడ ఈ గేర్ చిహ్నాన్ని పై క్లిక్ చేసి ఉంది

218
00:14:02,000 --> 00:14:04,000
మరియు మీరు ఒక వాదన జోడించండి ఉంటుంది.

219
00:14:04,000 --> 00:14:10,000
మేము ఒక కమాండ్ లైన్ వాదన లో పాస్ కావలసిన నుండి మీరు కీ వాదన ఇవ్వాలని ఉంటుంది.

220
00:14:10,000 --> 00:14:13,000
ఇక్కడ నేను సంఖ్య 3 ఇవ్వాలని వెళుతున్న. నేను 3 ఇష్టం.

221
00:14:13,000 --> 00:14:19,000
ఇప్పుడు, తిరిగి దూరంగా జూమ్ ప్రోగ్రామ్ను అమలు.

222
00:14:19,000 --> 00:14:24,000
దీనిని నిర్మించాలని, కంపైల్, అమలు చేసిన.

223
00:14:24,000 --> 00:14:27,000
ఇక్కడ మేము వెళ్ళండి. ఇది ప్రాంప్ట్ వేచి యొక్క.

224
00:14:27,000 --> 00:14:33,000
నేను హలో-పేరు లాగ టైప్ ఉంటే ఆ వెళ్ళి వచ్చింది?

225
00:14:33,000 --> 00:14:38,000
ఓహ్, నా ప్రోగ్రామ్ను అమలు చేయడానికి చాలా సమయం పట్టింది. నేను చాలా పొడవుగా కోసం jawing జరిగినది.

226
00:14:38,000 --> 00:14:40,000
ఇక్కడ ఇది వెళుతుంది.

227
00:14:40,000 --> 00:14:43,000
ఇప్పుడు నేను హలో లో టైప్ చేయండి.

228
00:14:43,000 --> 00:14:46,000
మేము తగిన గుప్తీకరిస్తుంది ఆ చూడండి.

229
00:14:46,000 --> 00:14:52,000
మేము శూన్య తిరిగి ప్రాంప్టులో GetString లేకపోతే ఇప్పుడు ఏమి జరుగుతుంది?

230
00:14:52,000 --> 00:14:57,000
గుర్తుంచుకోండి, మనం ఆ అని చెప్పారు అదే సమయంలో కంట్రోల్ D నొక్కడం ద్వారా.

231
00:14:57,000 --> 00:14:59,000
నేను ఇక్కడ స్క్రోల్ చేస్తాము. మేము మళ్లీ అమలు చేస్తాము.

232
00:14:59,000 --> 00:15:01,000
భవనం. అక్కడ అది వెళుతుంది.

233
00:15:01,000 --> 00:15:04,000
ఇప్పుడు నేను కంట్రోల్ D కొట్టాడు

234
00:15:04,000 --> 00:15:12,000
నేను opt/sandbox50/bin/run.sh అని ఈ లైన్, విభజన లోపంగా వచ్చింది.

235
00:15:12,000 --> 00:15:15,000
మీరు అబ్బాయిలు ఆ ముందు చూసిన?

236
00:15:15,000 --> 00:15:17,000
>> [స్టూడెంట్] ఎందుకు నో >> క్షమించాలి ఉంది?

237
00:15:17,000 --> 00:15:20,000
[స్టూడెంట్] ఎందుకు ఈ విషయంలో ఏ కోర్ డంప్ ఉంది?

238
00:15:20,000 --> 00:15:26,000
కోర్ డంప్ IS-ప్రశ్న ఎందుకు ఇక్కడ ఏ కోర్ డంప్ ఉంది?

239
00:15:26,000 --> 00:15:29,000
ప్రశ్న ఉంటాయని, కానీ కోర్ డంప్ ఫైలు

240
00:15:29,000 --> 00:15:31,000
ఆ హార్డు డ్రైవు నిల్వ ఉంటుంది.

241
00:15:31,000 --> 00:15:34,000
ఈ సందర్భంలో మనం కోర్ డంపుల ఆపివేసారు

242
00:15:34,000 --> 00:15:37,000
రన్ సర్వర్లో తద్వారా మేము ప్రజలు భ్రంశం ఏర్పడుతుంది seg లేదు

243
00:15:37,000 --> 00:15:40,000
మరియు కోర్ డంపుల టన్నుల ఏర్పాటు చేయడం.

244
00:15:40,000 --> 00:15:46,000
కానీ మీరు ఒక పొందుతుంది.

245
00:15:46,000 --> 00:15:48,000
కోర్ డంపుల, మీరు తరచుగా ఆపివేయగల విషయం యొక్క విధమైన ఉంటాయి

246
00:15:48,000 --> 00:15:52,000
మరియు కొన్నిసార్లు మీరు.

247
00:15:52,000 --> 00:15:55,000
విభజన లోపంగా, మీ ప్రశ్నకు సమాధానం, బాసిల్,

248
00:15:55,000 --> 00:16:00,000
మేము ఒక పాయింటర్ యాక్సెస్ చేసేందుకు ప్రయత్నించారు చెప్పి ఉంది

249
00:16:00,000 --> 00:16:05,000
ఆ ఏదైనా సూచించడానికి సెట్ లేదు.

250
00:16:05,000 --> 00:16:09,000
Binky చెయ్యడానికి ప్రయత్నించినప్పుడు వీడియో లో Binky గుర్తుంచుకో

251
00:16:09,000 --> 00:16:12,000
ఏదైనా సూచించే కాదు ఒక పాయింటర్ యాక్సెస్ వెళ్ళాలి?

252
00:16:12,000 --> 00:16:16,000
ఈ సందర్భంలో నేను సాంకేతికంగా పాయింటర్ ఏదో కు సూచిస్తుంది అంచనా.

253
00:16:16,000 --> 00:16:20,000
ఇది సాంకేతికంగా 0 ఇది శూన్య, సూచించే యొక్క

254
00:16:20,000 --> 00:16:25,000
కానీ ఆ అందుబాటులో లేని ఒక విభాగంలో నిర్వచించబడినది

255
00:16:25,000 --> 00:16:28,000
మీ ప్రోగ్రామ్ ద్వారా, మీరు విభజన లోపంగా పొందండి

256
00:16:28,000 --> 00:16:31,000
మీరు మెమరీ యాక్సెస్ లేదు ఎందుకంటే ఒక చెల్లుబాటు అయ్యే విభాగంలో ఉంది

257
00:16:31,000 --> 00:16:38,000
కుప్ప విభాగంలో లేదా స్టాక్ విభాగంలో లేదా డేటా విభాగంలో ఇష్టపడుతున్నారు.

258
00:16:38,000 --> 00:16:40,000
కూల్.

259
00:16:40,000 --> 00:16:48,000
సీజర్ గురించి ప్రశ్నలు?

260
00:16:48,000 --> 00:16:51,000
>> యొక్క ముందుకు లెట్. నిజంగా త్వరగా కూర్పుల 2 చూడండి యొక్క లెట్.

261
00:16:51,000 --> 00:17:00,000
ఆ విజెనెరే ఉంది.

262
00:17:00,000 --> 00:17:04,000
ఇక్కడ విజెనెరే లో

263
00:17:04,000 --> 00:17:06,000
మేము, మళ్ళీ, ఎందుకంటే చాలా త్వరగా ఈ ద్వారా ఉంటాము

264
00:17:06,000 --> 00:17:10,000
విజెనెరే మరియు సీజర్ పూర్తిగా ఒకేవిధంగా ఉంటాయి.

265
00:17:10,000 --> 00:17:12,000
శీర్షిక వ్యాఖ్య ముందు,

266
00:17:12,000 --> 00:17:17,000
ఈ మాయా సంఖ్యలు ఉపయోగించకుండా ఉండటానికి ముందు # define ఉంది.

267
00:17:17,000 --> 00:17:21,000
nice విషయం మేము తరలించడానికి కోరుకున్నారు చెప్పాలి

268
00:17:21,000 --> 00:17:23,000
ఆ వంటి వివిధ వర్ణమాల లేదా ఏదో.

269
00:17:23,000 --> 00:17:26,000
అయితే అన్ని 26 యొక్క కోడ్ లో మార్పు మానవీయంగా వెళ్ళి అవసరం కంటే

270
00:17:26,000 --> 00:17:30,000
మేము 27 ఈ మార్చండి లేదా దానిని డౌన్ తగ్గుతుందని

271
00:17:30,000 --> 00:17:34,000
మేము వివిధ వర్ణమాలలు వివిధ భాషలలో ఉపయోగించి ఉంటే.

272
00:17:34,000 --> 00:17:38,000
మళ్లీ, మేము, వాదన లెక్క ఈ చెక్ పొందారు

273
00:17:38,000 --> 00:17:42,000
మరియు నిజంగా మీరు దాదాపు ఒక టెంప్లేట్ ఈ పడుతుంది.

274
00:17:42,000 --> 00:17:46,000
మీరు వ్రాసే ప్రెట్టీ చాలా ప్రతి ప్రోగ్రామ్ను-చేయాలి

275
00:17:46,000 --> 00:17:50,000
రేఖల ఇది కమాండ్ లైన్ తీసుకుంటే వాదనలు-కొన్ని క్రమాన్ని

276
00:17:50,000 --> 00:17:55,000
చాలా ప్రారంభంలో ఈ వంటి చదువుతుంది.

277
00:17:55,000 --> 00:17:59,000
మీరు చేయాలనుకుంటున్నారా మొదటి తెలివి పరీక్షలు ఒకటి.

278
00:17:59,000 --> 00:18:03,000
>> ఇక్కడ మేము ఖచ్చితంగా ఆ చేసిన చేసినది

279
00:18:03,000 --> 00:18:06,000
కీవర్డ్ చెల్లుబాటు అయ్యే, ఆ మేము ఆ రెండవ చెక్ ఉంది.

280
00:18:06,000 --> 00:18:11,000
మేము argc మరియు 2 నుండి ఈ వేరు అని మళ్ళీ గమనించండి.

281
00:18:11,000 --> 00:18:14,000
ఈ సందర్భంలో మనం వచ్చింది ఒక విషయం బదులుగా గమనించండి

282
00:18:14,000 --> 00:18:18,000
నేను ఒక ఉపయోగించి యొక్క మేము మొత్తం స్ట్రింగ్ ధ్రువీకరించడానికి కోరుకున్నారు

283
00:18:18,000 --> 00:18:21,000
మరియు క్రమంలో మీరు నిజంగా పాత్ర పాత్ర వెళ్ళడానికి కలిగి చేయడానికి

284
00:18:21,000 --> 00:18:23,000
స్ట్రింగ్ మీద.

285
00:18:23,000 --> 00:18:29,000
దానిపై ఏదో కాల్ ఎటువంటి మంచి మార్గం లేదు

286
00:18:29,000 --> 00:18:31,000
కూడా, ఉదాహరణకు, ఒక నేను 0 తిరిగి ఎందుకంటే

287
00:18:31,000 --> 00:18:37,000
అది ఒక పూర్ణాంకం అన్వయించడం సాధ్యం కాదు ఉంటే, కూడా పని చేయని విధంగా.

288
00:18:37,000 --> 00:18:42,000
మళ్లీ, సరిగ్గా యూజర్ చెప్పడం nice సందేశాన్ని ఏమి.

289
00:18:42,000 --> 00:18:45,000
ఇక్కడ, మళ్ళీ, మేము కూడా కేసు నిర్వహించడానికి పేరు

290
00:18:45,000 --> 00:18:50,000
ఒక నియంత్రణ D యాదృచ్ఛిక పాత్ర లో యూజర్ రకాల.

291
00:18:50,000 --> 00:18:54,000
>> ఆపై షార్లెట్ మేము ఖాళీలను దాటవేయడానికి నిర్వహించండి ఎలా ఒక ప్రశ్న క్రితం

292
00:18:54,000 --> 00:18:57,000
ఇక్కడ మా స్ట్రింగ్ లో.

293
00:18:57,000 --> 00:19:00,000
ఈ మేము మైస్పేస్ కార్యక్రమం ఏమి పోలి రకమైన ఉంది

294
00:19:00,000 --> 00:19:04,000
మేము విభాగంలో, మరియు ఈ విధంగా పని

295
00:19:04,000 --> 00:19:08,000
మేము చూసిన మీరు ఆ అక్షరాల సంఖ్య ట్రాక్ ఉంది.

296
00:19:08,000 --> 00:19:13,000
మేము పాత్ర పాత్ర లేచి వంటి, మేము, సందేశం స్ట్రింగ్ లేచి

297
00:19:13,000 --> 00:19:16,000
మేము లూప్ మా భాగంగా సూచిక ట్రాక్, మరియు అప్పుడు మేము కూడా ట్రాక్

298
00:19:16,000 --> 00:19:21,000
అక్షరాల సంఖ్య, కాబట్టి కాని ప్రత్యేక అక్షరాలు, కాని అంకెలు, కాని వైట్ స్పేస్

299
00:19:21,000 --> 00:19:27,000
మేము ప్రత్యేక వేరియబుల్ చూడవచ్చు భావిస్తున్నట్టు.

300
00:19:27,000 --> 00:19:33,000
మరియు ఈ పరిష్కారం కీ మార్పు

301
00:19:33,000 --> 00:19:41,000
ఒక వాస్తవ కీ పూర్ణాంక పొందండి, మరియు అది ఎగిరి ఆ చేస్తుంది కు,

302
00:19:41,000 --> 00:19:47,000
అది నిజమైన సందేశం పాత్ర గుప్తీకరించడానికి వెళుతుంది కుడి ముందు.

303
00:19:47,000 --> 00:19:50,000
చాలా ఖచ్చితంగా గొప్ప కొన్ని SOLUTIONS ఉన్నాయి

304
00:19:50,000 --> 00:19:58,000
కీ యొక్క చెల్లుబాటును కోసం పరీక్ష చేసినప్పుడు కీ అప్ సవరించడానికి చేస్తుంది.

305
00:19:58,000 --> 00:20:01,000
చూసుకోవాలి పాటు ఆ పాత్ర మరియు కీవర్డ్

306
00:20:01,000 --> 00:20:05,000
అక్షరమాల పాత్ర అది కూడా ఒక పూర్ణాంకం మారింది

307
00:20:05,000 --> 00:20:13,000
0 to 25 పరిధిలో తర్వాత లూప్ ఈ లో ఆ తరువాత అవసరం దాటవేయడానికి.

308
00:20:13,000 --> 00:20:18,000
మరలా, మీరు ఇది నిజంగా ఖచ్చితమైన కోడ్ ఇక్కడ చూడండి

309
00:20:18,000 --> 00:20:22,000
మేము ఈ సమయంలో సీజర్ లో ఉపయోగించారు.

310
00:20:22,000 --> 00:20:25,000
మీరు ఖచ్చితమైన పనిని చేస్తున్న, రియల్ ట్రిక్ ఇందుకు అందువలన

311
00:20:25,000 --> 00:20:30,000
పూర్ణాంకం లోకి కీవర్డ్ మలుపు ఎలా.

312
00:20:30,000 --> 00:20:35,000
>> ఒక విషయం మనం ఇక్కడ చేసిన ఒక చిన్న దట్టమైన అని

313
00:20:35,000 --> 00:20:39,000
మేము ఈ పదబంధం పునరావృతమవుతుంది, నేను, మీరు కాల్ కాలేదు ఊహించడం

314
00:20:39,000 --> 00:20:45,000
పంక్తులు 58, 59, మరియు 61 న 3 ప్రత్యేక టైమ్స్.

315
00:20:45,000 --> 00:20:52,000
ఎవరైనా ఖచ్చితంగా ఈ పదబంధం ఏమి వివరిస్తుంది?

316
00:20:52,000 --> 00:20:55,000
మీరు చెప్పినట్టూ ఇది ఒక పాత్ర యాక్సెస్ ఉంటుంది.

317
00:20:55,000 --> 00:20:59,000
అవును, అది, కీవర్డ్ లో [వినబడని] ఒక పాత్ర

318
00:20:59,000 --> 00:21:04,000
మీరు మాత్రమే పాటు కదిలే అయినందున మరియు కనుక ఇది చూసిన అక్షరాలను సంఖ్య యొక్క

319
00:21:04,000 --> 00:21:06,000
మీరు లేఖ చూసిన ఒకసారి కీవర్డ్,

320
00:21:06,000 --> 00:21:10,000
అది ప్రభావవంతంగా ఖాళీలను మరియు వంటి అంశాలను దాటవేయడానికి జరగబోతోంది ఆ.

321
00:21:10,000 --> 00:21:12,000
అవును, సరిగ్గా.

322
00:21:12,000 --> 00:21:16,000
మీరు చుట్టూ తిరిగి తరలించడానికి కాబట్టి ఆపై మీరు మీరు mod కీవర్డ్ ఖాళీ చూసిన.

323
00:21:16,000 --> 00:21:18,000
సరిగ్గా. ఒక పరిపూర్ణ వివరణ ఉంది.

324
00:21:18,000 --> 00:21:23,000
ఏ కెవిన్ చెప్పాడు మేము కీవర్డ్ లోకి సూచిక చేయదలిచిన ఉంది.

325
00:21:23,000 --> 00:21:28,000
మీరు రెడీ ఉంటే, మేము, num_letters_seen పాత్ర పొందడానికి కావలసిన

326
00:21:28,000 --> 00:21:32,000
కానీ num_letters_seen కీవర్డ్ యొక్క పొడవు అతిక్రమిస్తే,

327
00:21:32,000 --> 00:21:37,000
మేము తగిన స్థాయిలో తిరిగి పొందడానికి మార్గం మేము mod ఆపరేటర్లు ఉపయోగిస్తారు

328
00:21:37,000 --> 00:21:40,000
సమర్థవంతంగా చుట్టూ.

329
00:21:40,000 --> 00:21:43,000
ఉదాహరణకు, చిన్న వలె మా కీవర్డ్, పంది మాంసం ఉంటుంది

330
00:21:43,000 --> 00:21:46,000
మరియు అది 5 అక్షరాలు ఉంది.

331
00:21:46,000 --> 00:21:50,000
కానీ మేము ఈ సమయంలో మా సాదా టెక్స్ట్లో 6 అక్షరాలు చూసిన

332
00:21:50,000 --> 00:21:52,000
మరియు 6 గుప్తీకరించబడింది.

333
00:21:52,000 --> 00:21:57,000
మేము, num_letters_seen యాక్సెస్ అప్ ముగుస్తుంది

334
00:21:57,000 --> 00:22:00,000
ఇది కీవర్డ్ యొక్క mod పొడవు, 5, 6

335
00:22:00,000 --> 00:22:04,000
అందువలన మేము ఏమి మేము చేస్తాము మేము చేస్తాము కాబట్టి 1 పొందండి, మరియు మీరు

336
00:22:04,000 --> 00:22:14,000
ఆ సమయంలో మా కీవర్డ్ మొదటి అక్షరం లోపల యాక్సెస్.

337
00:22:14,000 --> 00:22:21,000
>> All right, విజెనెరే ఏ ప్రశ్నలు

338
00:22:21,000 --> 00:22:26,000
మేము ముందుకు ముందు?

339
00:22:26,000 --> 00:22:31,000
మీరు అబ్బాయిలు ఈ గురించి చాలా ఫీలింగ్ గుడ్?

340
00:22:31,000 --> 00:22:35,000
గొప్ప, కూల్.

341
00:22:35,000 --> 00:22:38,000
నేను మీరు అబ్బాయిలు కోడ్ చూడటానికి అవకాశం పొందడానికి అని నిర్ధారించుకోవాలి

342
00:22:38,000 --> 00:22:48,000
మేము బాగుంది భావిస్తున్నాను మరియు దాని నుండి తెలుసుకోవడానికి అవకాశం కలిగి.

343
00:22:48,000 --> 00:22:53,000
ఈ మేము ప్రస్తుతానికి ఖాళీలను ఉపయోగించి వస్తుంది చివరి అన్నారు

344
00:22:53,000 --> 00:22:59,000
మరియు మేము ఇప్పుడు పరివర్తన చూడాలని, మరియు నేను cs50.net/lectures వెళ్ళండి వెళుతున్న

345
00:22:59,000 --> 00:23:06,000
కాబట్టి మేము క్విజ్ సమీక్ష యొక్క కొద్దిగా చేయవచ్చు.

346
00:23:06,000 --> 00:23:10,000
నేను క్విజ్ సమీక్ష చేయడం మొదలు అనుకుంటున్నాను ఉత్తమ మార్గం

347
00:23:10,000 --> 00:23:15,000
ఈ ఉపన్యాసాలు పేజీ రావలసియున్నదని, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
మరియు వారం శీర్షికలు ప్రతి కింద, నేను, వీక్ 0 వద్ద ఇక్కడ చూస్తే

349
00:23:20,000 --> 00:23:27,000
మనం మనం వీక్ 0 లో కవర్ విషయాలు ఒక జాబితా చూడండి.

350
00:23:27,000 --> 00:23:31,000
>> ఈ విషయాలు ఏ మీకు తెలియని కనిపిస్తుంది ఉంటే

351
00:23:31,000 --> 00:23:34,000
మీరు ఖచ్చితంగా లెక్చర్ నోట్స్ మరియు బహుశా తిరిగి వెళ్లి మెరుగుపెట్టు చెయ్యవచ్చును

352
00:23:34,000 --> 00:23:39,000
మీరు కోరుకుంటే కూడా ఉపన్యాసాలు ద్వారా చెడిపోయిన, మళ్ళీ వాటిని చూసే

353
00:23:39,000 --> 00:23:44,000
ఆ విషయాలు ప్రతి ఒక్క ఏమి కోసం ఒక భావాన్ని పొందడానికి.

354
00:23:44,000 --> 00:23:49,000
నేను అదనంగా మేము పొందారు చల్లని వనరుల ఈ సంవత్సరం ఒక యున్నది

355
00:23:49,000 --> 00:23:55,000
మేము సృష్టించిన ఈ లఘు చిత్రాలు, మరియు మీరు వీక్ 0 విషయంలో చూస్తే,

356
00:23:55,000 --> 00:24:00,000
, మేము కవర్ అంశాలపై అన్ని లేదు, కానీ మేము వాటిని కొద్ది పొందారు

357
00:24:00,000 --> 00:24:03,000
trickier వాటిలో, మరలా ఈ లఘు చిత్రాలు చూడటం

358
00:24:03,000 --> 00:24:08,000
వేగవంతం మీకు పొందడానికి మంచి మార్గం.

359
00:24:08,000 --> 00:24:15,000
ముఖ్యంగా, నేను ఆ కారణంగా, అడుగున 3 ఒక ప్లగ్ ఉంచారు వెళుతున్న.

360
00:24:15,000 --> 00:24:20,000
కానీ మీరు బైనరీ తో పోరాడుతున్న చేస్తుంటే, బిట్స్, hex, వాటిలో ఆ విధమైన,

361
00:24:20,000 --> 00:24:22,000
బైనరీ ప్రారంభించడానికి ఒక గొప్ప ప్రదేశం.

362
00:24:22,000 --> 00:24:25,000
ASCII చాలా వీక్షించడానికి మంచి మరొక ఒకటి.

363
00:24:25,000 --> 00:24:31,000
మీ కోసం నేను చాలా నెమ్మదిగా వెళుతున్న మీరు కూడా 1.5x వేగం వద్ద నాకు చూడవచ్చు.

364
00:24:31,000 --> 00:24:35,000
అది యొక్క సమీక్ష నుండి, అలా సంకోచించకండి.

365
00:24:35,000 --> 00:24:40,000
>> జస్ట్ నిజంగా త్వరగా ప్రారంభించడానికి, మేము ఈ క్విజ్ సమస్యలను జంట ద్వారా వెళ్ళడానికి వెళుతున్న

366
00:24:40,000 --> 00:24:44,000
కేవలం త్వరగా ఈ ద్వారా చిలుకుతాయి కు.

367
00:24:44,000 --> 00:24:50,000
ఉదాహరణకు, యొక్క నేను బోర్డు మీద కుడి అప్ ఇక్కడ పొందారు సమస్య 16 చూద్దాం.

368
00:24:50,000 --> 00:24:54,000
మేము, బైనరీ లో ఈ క్రింది లెక్కింపు పొందారు

369
00:24:54,000 --> 00:24:56,000
మరియు మేము ఏ పని చూపాలనుకుంటున్న.

370
00:24:56,000 --> 00:24:59,000
ఓకే, నేను ఈ షాట్ ఇవ్వాలని వెళుతున్న.

371
00:24:59,000 --> 00:25:01,000
మీరు అబ్బాయిలు, కాగితం పాటు తప్పక

372
00:25:01,000 --> 00:25:04,000
మరియు మేము నిజంగా త్వరగా చేస్తాను.

373
00:25:04,000 --> 00:25:06,000
మేము బైనరీ కింది గణితము మీరు.

374
00:25:06,000 --> 00:25:16,000
నేను 00110010 పొందారు.

375
00:25:16,000 --> 00:25:27,000
మరియు నేను దానిని 00110010 జోడించండి వెళుతున్న.

376
00:25:27,000 --> 00:25:30,000
గణిత కోసం, ఇంటి వద్ద వెంట తరువాత విజయంతో

377
00:25:30,000 --> 00:25:35,000
ఈ సమర్థవంతంగా 2 గుణించడం ఉంది.

378
00:25:35,000 --> 00:25:37,000
ప్రారంభిద్దాం.

379
00:25:37,000 --> 00:25:39,000
మేము ఏమి అదే అదనంగా అల్గోరిథం అనుసరించండి చూడాలని

380
00:25:39,000 --> 00:25:43,000
మేము కలిసి దశాంశ సంఖ్యలు జతచేయునప్పుడు.

381
00:25:43,000 --> 00:25:46,000
రియల్లీ ఇక్కడ మాత్రమే తేడా మేము లూప్ తిరిగి చుట్టూ ఆ

382
00:25:46,000 --> 00:25:51,000
ఒకసారి మేము 1 + 1 బదులుగా ఒకసారి మేము 10 ను కలిగి ఉంటాయి.

383
00:25:51,000 --> 00:25:53,000
>> మేము నిజంగా త్వరగా, కుడి నుండి ప్రారంభం ఉంటే, ఏ మొదటి అంకెల ఏమిటి?

384
00:25:53,000 --> 00:25:55,000
[స్టూడెంట్] 0. >> [నేట్ H.] 0.

385
00:25:55,000 --> 00:25:58,000
గ్రేట్, రెండవ అంకెల?

386
00:25:58,000 --> 00:26:00,000
[స్టూడెంట్] 1.

387
00:26:00,000 --> 00:26:02,000
[నేట్ H.] ఇది 1? 1 + 1?

388
00:26:02,000 --> 00:26:04,000
[స్టూడెంట్] 10.

389
00:26:04,000 --> 00:26:08,000
[నేట్ H.] ఖచ్చితంగా నేను కలుపుతారు 2 వాటిని కింద కుడి వ్రాసే అంకెల కాబట్టి ఏమిటి?

390
00:26:08,000 --> 00:26:11,000
[స్టూడెంట్] 1, 0, 0 లేదా ఆపై 1 పడ్డారు.

391
00:26:11,000 --> 00:26:15,000
[నేట్ H.] 0 మరియు ఖచ్చితంగా ఒక 1 పడ్డారు.

392
00:26:15,000 --> 00:26:18,000
తదుపరి అప్, బాసిల్, మీరు అప్ ఉన్నారు.

393
00:26:18,000 --> 00:26:20,000
మూడవ ఏమిటి? >> [బాసిల్] 1.

394
00:26:20,000 --> 00:26:23,000
[నేట్ H.] 1, ఖచ్చితమైన. కెవిన్?

395
00:26:23,000 --> 00:26:27,000
[కెవిన్] 0. >> [నేట్ H.] 0, షార్లెట్?

396
00:26:27,000 --> 00:26:30,000
[షార్లెట్] 0. >> [నేట్ H.] అవును, నేను ఏమి చేస్తారు?

397
00:26:30,000 --> 00:26:32,000
[స్టూడెంట్] 1.

398
00:26:32,000 --> 00:26:34,000
[నేట్ H.] నేను ఏమి చేస్తారు? మరియు నేను 1 పడ్డారు.

399
00:26:34,000 --> 00:26:36,000
పర్ఫెక్ట్, Sahb? >> [Sahb] ఇప్పుడు మీరు 1 ఉన్నాయి.

400
00:26:36,000 --> 00:26:40,000
[నేట్ H.] నేను ఇక్కడ ఏదైనా ఎందుకు చేయాలి?

401
00:26:40,000 --> 00:26:43,000
[Sahb] అప్పుడు మీరు 1 కొనసాగింది ఎందుకంటే మీరు 1 కలిగి తదుపరి కోసం.

402
00:26:43,000 --> 00:26:49,000
[నేట్ H.] గ్రేట్, కాబట్టి ఇక్కడ దానిని ముగించవచ్చు.

403
00:26:49,000 --> 00:26:51,000
కూల్.

404
00:26:51,000 --> 00:26:54,000
[స్టూడెంట్] 0 + 0 = 0 ఇవ్వగలవా?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, మీరు చెప్పినట్టూ, 0 10, లేదా 1 అనేది.

407
00:27:01,000 --> 00:27:07,000
10 నాకు 10 సంఖ్య 10 అనగా ఎందుకంటే ఒక తగని,

408
00:27:07,000 --> 00:27:12,000
మరియు అది వ్రాస్తున్నప్పుడు మేము అది ప్రాతినిధ్యం చేస్తున్నారు ఎలా నటన ఉంది.

409
00:27:12,000 --> 00:27:20,000
మేము 1, 0 ద్వారా సంఖ్య 2 సూచిస్తాయి, మరియు సంఖ్య 10 కొద్దిగా వ్యత్యాసం ఉంటుంది.

410
00:27:20,000 --> 00:27:23,000
>> బైనరీ గురించి nice రకం ఏమిటి నిజంగా చాలా ఉన్నాయి కాని ఉంది

411
00:27:23,000 --> 00:27:25,000
మీరు తెలుసుకోవడానికి అవసరం కేసులు.

412
00:27:25,000 --> 00:27:30,000
0 + 0 = 0, 0 + 1 = 1, ఉన్నాయి

413
00:27:30,000 --> 00:27:34,000
1 + 1 0, తరువాత, ఒక 1 తీసుకు

414
00:27:34,000 --> 00:27:37,000
మరియు తర్వాత మీరు కుడి నుండి మూడవ కాలమ్ లో ఇక్కడ చూడవచ్చు

415
00:27:37,000 --> 00:27:40,000
మేము ఈ 1, 1, 1 మరియు వచ్చింది.

416
00:27:40,000 --> 00:27:43,000
మరియు 1 + 1 + 1, ఒక 1

417
00:27:43,000 --> 00:27:45,000
మరియు మీరు మరొక 1 పడ్డారు.

418
00:27:45,000 --> 00:27:48,000
మీరు బైనరీ అదనంగా చేయడం చేసినప్పుడు, చాలా సాధారణ.

419
00:27:48,000 --> 00:27:51,000
నేను తెలివి నిన్ను నీవు తనిఖీ ఈ రెండు మరింత పెంచండి

420
00:27:51,000 --> 00:27:54,000
మీరు ఈ ఎందుకంటే వెళ్ళడానికి ముందు

421
00:27:54,000 --> 00:28:00,000
బహుశా మేము క్విజ్ న చూస్తారు ఏదో.

422
00:28:00,000 --> 00:28:03,000
ఇప్పుడు ఈ తదుపరి ఏమి చూద్దాం.

423
00:28:03,000 --> 00:28:06,000
సమస్య 17 ఏమి యొక్క లెట్.

424
00:28:06,000 --> 00:28:12,000
మేము దశాంశ కింది బైనరీ సంఖ్య మార్చేందుకు వెళుతున్న.

425
00:28:12,000 --> 00:28:28,000
నేను 10100111001 పొందారు.

426
00:28:28,000 --> 00:28:33,000
ఐ డిడ్ ఆ బైనరీ వీడియో లో గుర్తుంచుకో

427
00:28:33,000 --> 00:28:36,000
నేను ఉదాహరణలు ఒక జంట ద్వారా వెళ్ళిపోయాడు మరియు నేను ఎలా చూపించింది

428
00:28:36,000 --> 00:28:41,000
మీరు దశాంశ లో చేయుచున్నారు ఉన్నప్పుడు ప్రతిదీ పనిచేస్తుంది.

429
00:28:41,000 --> 00:28:45,000
మీరు దశాంశ ప్రాతినిధ్యం లో పనిచేసే మనం భావిస్తున్నాను

430
00:28:45,000 --> 00:28:48,000
అది మన జీవితాల్లో ఈ సమయంలో అలా స్పష్టమైన ఆ

431
00:28:48,000 --> 00:28:53,000
ఇది వాస్తవంగా ఎలా పనిచేస్తుంది మెకానిక్స్ పై వ్యాఖ్యానం కు అందంగా సులభం.

432
00:28:53,000 --> 00:28:59,000
>> నేను సంఖ్య 137 అయితే, శీఘ్ర రీక్యాప్ చేయడానికి

433
00:28:59,000 --> 00:29:06,000
ఇది నిజంగా అర్థం పైన మరియు మళ్లీ ఈ దశాంశ ఉంది ప్రాతినిధ్యం-

434
00:29:06,000 --> 00:29:19,000
దశాంశ లో 137 నేను 1 x 100 + 3 x 10 + 7 x 1 ఉండవు.

435
00:29:19,000 --> 00:29:22,000
ఈ అన్ని తెరపై ఉంటున్న ఉంది.

436
00:29:22,000 --> 00:29:29,000
ఆపై మీరు ఇక్కడే ఈ సంఖ్యలో చూస్తే

437
00:29:29,000 --> 00:29:34,000
100, 10 మరియు 1, వారు నిజంగా 10 యొక్క అన్ని అధికారాలు మేము చూసాము.

438
00:29:34,000 --> 00:29:43,000
నేను సున్నా 10 ², 10 ¹, మరియు 10 ఉన్నాయి.

439
00:29:43,000 --> 00:29:48,000
మేము, బైనరీ లో విషయం ఇదే విధమైన కలిగి

440
00:29:48,000 --> 00:29:55,000
ఆ తప్ప మా బేస్, మేము ఇది కూడా పిలుస్తారు, 10 2 బదులుగా ఉంటుంది.

441
00:29:55,000 --> 00:29:58,000
నేను క్రింద ఇక్కడ డౌన్ రాసిన ఈ 10s,

442
00:29:58,000 --> 00:30:02,000
ఈ 10 ², 10 ¹, సున్నా, 10 నుండి 10, మా బేస్ ఉంది

443
00:30:02,000 --> 00:30:08,000
మరియు విశేషము, 0, 1, లేదా 2,

444
00:30:08,000 --> 00:30:14,000
మేము వ్రాసే సంఖ్య అంకెల యొక్క స్థానం ఊహాజనితం.

445
00:30:14,000 --> 00:30:21,000
మేము దాన్ని చూస్తే 1, ఈ 1 2 స్థానంలో ఉంది.

446
00:30:21,000 --> 00:30:27,000
3 1 వ స్థానంలో ఉంది, మరియు 7 0th స్థానంలో ఉంది.

447
00:30:27,000 --> 00:30:35,000
అంటే మా స్థావరాలను వివిధ కళాకారుల్లో పొందండి ఎలా.

448
00:30:35,000 --> 00:30:40,000
>> ఈ we'll-వాస్తవానికి అన్ని తరువాత, మీరు ఏమి?

449
00:30:40,000 --> 00:30:43,000
మేము నా దిద్దుబాటు రద్దుచెయ్యి బటన్ ఏమి-ఏమి అయ్యాయి చేస్తాము?

450
00:30:43,000 --> 00:30:45,000
అక్కడ అది వెళుతుంది.

451
00:30:45,000 --> 00:30:47,000
నేను ఈ విషయం దిద్దుబాటు రద్దుచెయ్యి ప్రేమ.

452
00:30:47,000 --> 00:30:51,000
ఈ నేపథ్యంలో నేను కనీసం నాకు అనుకుంటున్నాను

453
00:30:51,000 --> 00:30:54,000
ఒక బైనరీ సంఖ్య మార్పిడి ప్రారంభించడానికి సులభమైన మార్గం

454
00:30:54,000 --> 00:30:57,000
బేస్ 16 ఉన్న లేదా ఒక హెక్సాడెసిమల్ సంఖ్య

455
00:30:57,000 --> 00:31:02,000
మరియు 10 లేదా 2 ముందుకు వెళ్లి అవుట్ రచన

456
00:31:02,000 --> 00:31:09,000
ఎగువన నా బైనరీ సంఖ్య సంఖ్యల అన్ని స్థావరాలు మరియు పరిశోధకులు.

457
00:31:09,000 --> 00:31:14,000
మేము మళ్ళీ ఎడమ నుండి ప్రారంభం ఉంటే,

458
00:31:14,000 --> 00:31:17,000
counterintuitive రకం, ఇది

459
00:31:17,000 --> 00:31:23,000
నేను ఇక్కడ నలుపు తిరిగి మారుస్తాము, మేము, 0th స్థానం 2 కలిగి

460
00:31:23,000 --> 00:31:27,000
మరియు తర్వాత మేము 2 కలిగి ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
ఆపై 2 3, 5 2 4, 2, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, 10 మరియు.

463
00:31:39,000 --> 00:31:41,000
నేను వ్రాయలేదు ఈ సంఖ్యలు అన్ని ఆనవాళ్లుగా ఉంటాయి.

464
00:31:41,000 --> 00:31:48,000
నేను మాత్రమే కేవలం స్పేస్ మొదటి 3 ఇక్కడ స్థావరాలు రాశారు.

465
00:31:48,000 --> 00:31:50,000
>> ఈ సమయంలో నేను ముందుకు వెళుతున్న మరియు నిజానికి వేయండి వెళుతున్న

466
00:31:50,000 --> 00:31:53,000
సరే అయితే మేము, దశాంశ లో చేసిన విషయం.

467
00:31:53,000 --> 00:31:57,000
మీరు ఆ పొందారు.

468
00:31:57,000 --> 00:32:05,000
నేను ఖచ్చితంగా ఉన్నాను ఆన్లైన్ చూడటం మీరు ఆ మీరు కావాలనుకుంటే నాకు రివైండ్ చేయగలరు.

469
00:32:05,000 --> 00:32:07,000
పెన్ తిరిగి మార్పిడి.

470
00:32:07,000 --> 00:32:12,000
ఇప్పుడు, మనం చేయగలిగిందంతా-మీరు అబ్బాయిలు 2 యొక్క మీ శక్తులు న వేగవంతం పూర్తిగా అప్ కాదు,

471
00:32:12,000 --> 00:32:15,000
ఆ పూర్తిగా చల్లని ఉంది.

472
00:32:15,000 --> 00:32:18,000
ఇది జరుగుతుంది. నేను అర్థం చేసుకున్నాను.

473
00:32:18,000 --> 00:32:23,000
నేను 2 యొక్క అన్ని అధికారాలు తెలుసుకోవాలి చెప్పాడు నేను ఎక్కడ ఒకసారి ఒక ఉద్యోగ ఇంటర్వ్యూ కలిగి

474
00:32:23,000 --> 00:32:26,000
అప్ ద్వారా 2 30 వరకు.

475
00:32:26,000 --> 00:32:29,000
ఇది నేను ఒక ఉద్యోగం కాదు.

476
00:32:29,000 --> 00:32:32,000
, ఏమైనా, మీరు అబ్బాయిలు ముందుకు మరియు ఇక్కడ గణిత చేయండి

477
00:32:32,000 --> 00:32:35,000
కానీ బైనరీ తో నిజంగా సమంజసం అనిపించుకోదు

478
00:32:35,000 --> 00:32:38,000
మరియు లేదా, గాని దశాంశ లేదా హెక్సాడెసిమల్ తో సమంజసం లేదు

479
00:32:38,000 --> 00:32:43,000
మీరు సున్నాలు ఉంటుంది అవ్ట్ గణిత చేయడానికి.

480
00:32:43,000 --> 00:32:49,000
మీరు నేను ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ 0 0 0 0 0 0 కలిగి చూడగలరు.

481
00:32:49,000 --> 00:32:52,000
ఎందుకు అది నిజమైన గణిత చేయడానికి సమంజసం కాదు

482
00:32:52,000 --> 00:32:56,000
ఆ స్థానం కోసం 2 తగిన శక్తి లెక్కించేందుకు?

483
00:32:56,000 --> 00:32:59,000
షార్లెట్ చెప్పినట్టూ ఖచ్చితంగా, అది 0 ఉంటుంది.

484
00:32:59,000 --> 00:33:05,000
2 యొక్క శక్తులు గణన మీ బలమైన దావా లేకపోతే అలాగే మీరే సమయాన్ని ఆదా చేయవచ్చు.

485
00:33:05,000 --> 00:33:10,000
ఈ సందర్భంలో మనం మాత్రమే ఇది 0 to 2 కోసం లెక్కించడానికి అవసరం-?

486
00:33:10,000 --> 00:33:12,000
[స్టూడెంట్] 1.

487
00:33:12,000 --> 00:33:14,000
[నేట్ H.] 1, 2 3 ఏ IS-?

488
00:33:14,000 --> 00:33:16,000
[స్టూడెంట్] 8. >> [నేట్ H.] 8.

489
00:33:16,000 --> 00:33:18,000
2 నుంచి 4?

490
00:33:18,000 --> 00:33:21,000
[స్టూడెంట్] 2. నేను, క్షమించాలి 1 ఉన్నాను.

491
00:33:21,000 --> 00:33:26,000
[నేట్ H.] 2 4 ఖచ్చితంగా, 16 ఉంది.

492
00:33:26,000 --> 00:33:28,000
2 5, కెవిన్? >> 32.

493
00:33:28,000 --> 00:33:32,000
[నేట్ H.] 32, 2 8?

494
00:33:32,000 --> 00:33:38,000
[స్టూడెంట్] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[నేట్ H.] పర్ఫెక్ట్.

496
00:33:41,000 --> 00:33:43,000
మరియు 2 10?

497
00:33:43,000 --> 00:33:45,000
[స్టూడెంట్] 1024.

498
00:33:45,000 --> 00:33:49,000
[నేట్ H.] అవును, 1024.

499
00:33:49,000 --> 00:33:57,000
>> ఒకసారి మేము వాటిని మొత్తం సంకలనం ఈ సంఖ్యలు పొందారు.

500
00:33:57,000 --> 00:34:01,000
మరియు ఇది కొన్ని విషయాలను చేయడానికి చాలా ముఖ్యమైనది ఎక్కడ ఉంది.

501
00:34:01,000 --> 00:34:07,000
ఒక నెమ్మది వెళ్ళి మీ పని తనిఖీ ఉంది.

502
00:34:07,000 --> 00:34:10,000
మీరు ఈ సంఖ్య చివరిలో ఒక 1 లేదు చెప్పవచ్చు

503
00:34:10,000 --> 00:34:15,000
నేను ఖచ్చితంగా నా ఫలితంగా బేసి సంఖ్య కావాలి

504
00:34:15,000 --> 00:34:18,000
అన్ని ఇతర వాటిని సరి సంఖ్యలను మాత్రం ఎందుకంటే

505
00:34:18,000 --> 00:34:21,000
అది ఒక బైనరీ సంఖ్య అని ఇచ్చిన.

506
00:34:21,000 --> 00:34:24,000
మీరు పరీక్ష ఈ పాయింట్ ను ఉంటే చేయడానికి ఇతర విషయం

507
00:34:24,000 --> 00:34:27,000
మరియు మీరు ఈ దూరం దాన్ని వ్రాయలేదు

508
00:34:27,000 --> 00:34:30,000
మరియు మీరు సమయం నుండి అమలు చేస్తున్నారు

509
00:34:30,000 --> 00:34:33,000
ఈ సమస్య విలువ అని పాయింట్ల సంఖ్య చూడండి.

510
00:34:33,000 --> 00:34:40,000
ఈ సమస్య, మీరు చూడండి-ఉంటే గా నా లాప్టాప్ తిరిగి ఫ్లిప్ వేగంగా

511
00:34:40,000 --> 00:34:44,000
ఈ సమస్య 2 పాయింట్లు విలువ ఉంటుంది, అందుచే అదనంగా యొక్క విధమైన కాదు

512
00:34:44,000 --> 00:34:47,000
మీరు నిజంగా సారి నొక్కినప్పుడు మీకు ద్వారా వెళ్ళి ఉండాలి.

513
00:34:47,000 --> 00:34:52,000
కానీ మేము ఐప్యాడ్ తిరిగి మారవచ్చు చేస్తాము, మరియు మేము నిజంగా త్వరగా ద్వారా వెళ్తారో.

514
00:34:52,000 --> 00:34:54,000
>> నేను మొదటి చిన్న సంఖ్యలో చేయడం ఇష్టం

515
00:34:54,000 --> 00:34:56,000
నేను ఆ సులభంగా కనుగొనేందుకు ఎందుకంటే.

516
00:34:56,000 --> 00:35:00,000
వారు చాలా సులభంగా కలిసి వెళ్ళి ఎందుకంటే నేను 32 మరియు 8 ఇష్టం, మరియు మేము 50 పొందండి.

517
00:35:00,000 --> 00:35:03,000
16 మరియు 1 17 పొందుతాడు.

518
00:35:03,000 --> 00:35:05,000
అక్కడ మేము, 57

519
00:35:05,000 --> 00:35:14,000
మరియు తర్వాత మేము ఈ మిగిలిన, అందుచే మేము, 156 57 చేయవచ్చు చేయవచ్చు.

520
00:35:14,000 --> 00:35:16,000
న వస్తాయి.

521
00:35:16,000 --> 00:35:19,000
మాన్, బాగా, యొక్క చూసేలా.

522
00:35:19,000 --> 00:35:27,000
మేము 57, 256, మరియు 1024 ఉంది.

523
00:35:27,000 --> 00:35:31,000
ఈ సమయంలో, నేను కేవలం ద్వారా వెళ్ళాలి.

524
00:35:31,000 --> 00:35:35,000
నేను క్లూ ఉంటుంది. నేను స్పష్టంగా ఈ లో చదవడానికి అవసరం.

525
00:35:35,000 --> 00:35:40,000
7, 6, మరియు 4, మీరు 17 పొందండి.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
అప్పుడు మేము 3 చేయండి, ఆపై మేము 1 పొందండి.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
ఈస్టర్ గుడ్డు, ఎవరైనా?

530
00:35:55,000 --> 00:35:59,000
ఎవరైనా ఈ సంఖ్య గుర్తించి?

531
00:35:59,000 --> 00:36:02,000
క్రిస్ సంఖ్య గుర్తించింది. అది, క్రిస్ శతకము

532
00:36:02,000 --> 00:36:04,000
[క్రిస్] లీట్.

533
00:36:04,000 --> 00:36:11,000
మీరు ఈ విషయంలో చూస్తే లీట్, కాబట్టి, అది లీట్ కనిపిస్తోంది.

534
00:36:11,000 --> 00:36:15,000
హ్యాకర్ విషయం. మధ్యంతర లేదా క్విజ్ కాకుండా విషయాలను ఆ రకమైన కోసం చూడండి.

535
00:36:15,000 --> 00:36:19,000
మీరు వాటిలో ఆ విధమైన చూడండి మరియు మీరు వొండరింగ్ ఉంటే "అహ్,"

536
00:36:19,000 --> 00:36:22,000
వాస్తవానికి ఏదో కావచ్చు.

537
00:36:22,000 --> 00:36:24,000
నాకు తెలీదు. డేవిడ్ అది సైన్ ఉంచడం ఇష్టపడ్డారు

538
00:36:24,000 --> 00:36:26,000
ఇది తెలివి తనిఖీ చెయ్యడానికి ఒక మంచి మార్గం.

539
00:36:26,000 --> 00:36:30,000
సరే ఇలా నేను ఏమి చూడగలరు.

540
00:36:30,000 --> 00:36:34,000
>> ఆ వారం 0/Week 1 విషయాలు అనిపిస్తుంది.

541
00:36:34,000 --> 00:36:39,000
మేము ఇప్పుడు మా ల్యాప్టాప్ తిరిగి మారవచ్చు ఉంటే,

542
00:36:39,000 --> 00:36:46,000
దూరంగా, మరియు ఇతర విషయాలను.

543
00:36:46,000 --> 00:36:50,000
మేము సమస్య సెట్లతో చాలా చేయడం చేసిన, ఇది ASCII ఉంది.

544
00:36:50,000 --> 00:36:55,000
రాజధాని A. ఈ అభిప్రాయం నిజంగా ఏమిటి?

545
00:36:55,000 --> 00:36:57,000
అది దశాంశ పూర్ణాంక తెలియకుండా.

546
00:36:57,000 --> 00:37:00,000
65, ASCII పట్టికలో జతపరచేది ఏమి ఉంది

547
00:37:00,000 --> 00:37:03,000
మరియు ఆ, కంప్యూటర్ అది వ్రాస్తాడు ఎలా కాబట్టి యొక్క

548
00:37:03,000 --> 00:37:06,000
మరియు మేము నిజంగా రాసే దూరంగా పొందడానికి చేసిన ఎలా

549
00:37:06,000 --> 00:37:09,000
పాత్ర రాజధాని A మరియు పాత్ర చిన్న

550
00:37:09,000 --> 00:37:14,000
మీరు చేస్తున్న చేసిన ఈ పరిష్కారాలను మరియు సమస్య సెట్లు కొన్ని.

551
00:37:14,000 --> 00:37:16,000
ఇతర విషయాలను.

552
00:37:16,000 --> 00:37:25,000
మేము ప్రకటనలు, బూలియన్ భావాలు, పరిస్థితులు, ఉచ్చులు, వేరియబుల్స్ మరియు దారాలను పొందారు.

553
00:37:25,000 --> 00:37:29,000
>> ఆ అన్ని చాలా సమంజసం కనిపిస్తుంది?

554
00:37:29,000 --> 00:37:35,000
ఈ పరిభాష కొన్ని సమయాల్లో కొద్దిగా అల్లరిగా ఉంది.

555
00:37:35,000 --> 00:37:46,000
నేను ఒక సెమికోలన్ తో ముగిసే చాలా ఏదో కోసం ఒక ప్రకటన ఆలోచించడానికి ఇష్టపడతాను.

556
00:37:46,000 --> 00:37:51,000
అటువంటి x వంటి ప్రకటనలు = 7, వేరియబుల్ చేస్తుంది,

557
00:37:51,000 --> 00:37:54,000
బహుశా x = 7 అని.

558
00:37:54,000 --> 00:38:01,000
బహుశా x, కూడా సంఖ్య 7 నిల్వ చేసే రకం

559
00:38:01,000 --> 00:38:05,000
అది ఒక పూర్ణాంకానికి లేదా బహుశా ఒక ఫ్లోట్ లేదా ఒక చిన్న లేదా చార్ యొక్క

560
00:38:05,000 --> 00:38:07,000
అలాంటిదే.

561
00:38:07,000 --> 00:38:12,000
బూలియన్ వ్యక్తీకరణ సమానం ఈ డబుల్ ఉపయోగిస్తుంది

562
00:38:12,000 --> 00:38:17,000
మరియు బ్యాంగ్, కంటే ఎక్కువ, తక్కువ కాకుండా సమానం లేదా సమానం కాదు

563
00:38:17,000 --> 00:38:22,000
కంటే తక్కువ లేదా వాటిలో ఆ విధమైన, సమానంగా.

564
00:38:22,000 --> 00:38:28,000
నిబంధనలు అప్పుడు ఉంటే ఇంకా ప్రకటనలు ఉంటాయి.

565
00:38:28,000 --> 00:38:32,000
నేను మీరు సంబంధిత లేకుండా ఒక else ఉండకూడదు గుర్తుంచుకోవాలి చేస్తుంది.

566
00:38:32,000 --> 00:38:37,000
అలాగే, మీరు ఉంటే సంబంధిత లేకుండా ఒక else ఉండకూడదు.

567
00:38:37,000 --> 00:38:40,000
ఉచ్చులు, మేము మీరు hammering చేసిన లూప్ల 3 రకాల రీకాల్

568
00:38:40,000 --> 00:38:43,000
విభాగాలు మరియు సమస్య సెట్లు గత రెండు.

569
00:38:43,000 --> 00:38:46,000
మీరు యూజర్ ఇన్ పుట్ చేస్తున్నారు ఉన్నప్పుడు ఉన్నప్పుడు ఉపయోగించి,

570
00:38:46,000 --> 00:38:51,000
ఒక ప్రత్యేక పరిస్థితికి వరకు ఉచ్చులు నిజమైన ఉంది ఉపయోగించి,

571
00:38:51,000 --> 00:38:56,000
మీరు అవసరం ఉంటే ఆపై ఉచ్చులు కోసం ఆ ఉపయోగించి

572
00:38:56,000 --> 00:39:01,000
మీరు ప్రస్తుతం ఉన్నారు లూప్ ఏ మళ్ళా తెలిసిన నేను దాని గురించి ఆలోచించండి ఎలా ఉంది.

573
00:39:01,000 --> 00:39:07,000
లేదా మీరు నేను చేయాలని స్ట్రింగ్ లో ప్రతి పాత్ర కోసం ఒక చేస్తున్నా ఉంటే,

574
00:39:07,000 --> 00:39:15,000
నేను ఆ అంశానికి చేయాలని వ్యూహం ప్రతి మూలకం కోసం.

575
00:39:15,000 --> 00:39:18,000
>> థ్రెడ్ మరియు సంఘటనలు.

576
00:39:18,000 --> 00:39:21,000
ఈ మేము, C అలా స్పష్టంగా కవర్ లేదు

577
00:39:21,000 --> 00:39:23,000
కానీ స్క్రాచ్ నుంచి ఈ గుర్తుంచుకోవాలి.

578
00:39:23,000 --> 00:39:26,000
ఈ విభిన్న స్క్రిప్ట్లు కలిగి చెప్పవచ్చు.

579
00:39:26,000 --> 00:39:32,000
ఈ కూడా ఒక ఈవెంట్ను ప్రసారం యొక్క ఈ భావన ఉంది.

580
00:39:32,000 --> 00:39:37,000
కొంతమంది ప్రారంభంలో వారి ప్రాజెక్టులలో ప్రసార ఉపయోగించడానికి లేదు

581
00:39:37,000 --> 00:39:40,000
ఇది పూర్తిగా బాగుంది

582
00:39:40,000 --> 00:39:46,000
కానీ ఈ, అనుకూలత అనే ఈ విషయం నిర్వహణ 2 వివిధ మార్గాలు

583
00:39:46,000 --> 00:39:49,000
ఇది ఎలా మీరు కార్యక్రమాలు అమలు ఎలా ఉంది

584
00:39:49,000 --> 00:39:54,000
లేదా అకారణంగా అదే సమయంలో అమలు?

585
00:39:54,000 --> 00:39:59,000
ఇతర పనులు కూడా అమలు అయితే వివిధ పనులు అమలు.

586
00:39:59,000 --> 00:40:01,000
ఇది మీ ఆపరేటింగ్ సిస్టమ్ పని ఉంది ఎలా ఉంది.

587
00:40:01,000 --> 00:40:04,000
ఈ ఉదాహరణకు, ఎందుకు అయినప్పటికీ ఉంది

588
00:40:04,000 --> 00:40:10,000
నా బ్రౌజర్ అమలులో గాట్, నేను కూడా Spotify ఆన్ మరియు ఒక పాట ప్లే చేసుకోవచ్చు.

589
00:40:10,000 --> 00:40:14,000
అర్థం ఒక సంభావిత విషయం మరింత.

590
00:40:14,000 --> 00:40:17,000
నేను చిన్న థ్రెడ్ పరిశీలించి చేస్తుంది

591
00:40:17,000 --> 00:40:21,000
మీరు గురించి మరింత తెలుసుకోవడానికి చెయ్యాలనుకుంటే.

592
00:40:21,000 --> 00:40:26,000
>> యొక్క చూసేలా, నేను కూడా ఉండవచ్చు నమ్మకం

593
00:40:26,000 --> 00:40:31,000
ఈ ఒకటి ఈ సమస్య.

594
00:40:31,000 --> 00:40:35,000
మళ్ళీ, నేను దారాలు మరియు సంఘటనలు మేము సి లో కవర్ చేస్తుంది విషయం కాదు నా

595
00:40:35,000 --> 00:40:41,000
ఇది గణనీయంగా స్క్రాచ్ కంటే మరింత కష్టం కనుక.

596
00:40:41,000 --> 00:40:44,000
మీరు దానిని అక్కడ గురించి ఆందోళన, కానీ ఖచ్చితంగా భావనలు అర్థం కాదు

597
00:40:44,000 --> 00:40:47,000
ఏమి అర్థం.

598
00:40:47,000 --> 00:40:52,000
మేము ముందుకు ముందు, వీక్ ఏ ప్రశ్నలు 0 పదార్థం?

599
00:40:52,000 --> 00:40:55,000
అందరూ చాలా ఫీలింగ్ గుడ్?

600
00:40:55,000 --> 00:41:03,000
అండర్స్టాండింగ్ వేరియబుల్స్ మరియు ఒక చరరాశి?

601
00:41:03,000 --> 00:41:08,000
>> న మూవింగ్. వీక్ 1.

602
00:41:08,000 --> 00:41:12,000
ముఖ్యంగా కవర్ కాదు అని ఇక్కడ కొన్ని విషయాలను

603
00:41:12,000 --> 00:41:21,000
క్విజ్ సమీక్షలో తప్పనిసరిగా మరియు ఆలోచించడానికి మరింత సంభావిత విషయాలు ఇక్కడ ఉన్నాయి.

604
00:41:21,000 --> 00:41:30,000
మొదటి సోర్స్ కోడ్, స్వరకర్తలు మరియు వస్తువు కోడ్ ఏమిటో ఈ చెప్పవచ్చు.

605
00:41:30,000 --> 00:41:32,000
ఎవరైనా? బాసిల్.

606
00:41:32,000 --> 00:41:37,000
ఉంది వస్తువు కోడ్-I సోర్స్ కోడ్ మీరు గణగణమని ద్వని చేయు ఉంచి ఏమిటి అర్థం,

607
00:41:37,000 --> 00:41:42,000
మరియు వస్తువు కోడ్ ఏమి గణగణమని ద్వని చేయు మీ కంప్యూటర్ ప్రోగ్రామ్ చదువుకోవచ్చు తద్వారా ఉంచుతారు ఉంటుంది.

608
00:41:42,000 --> 00:41:44,000
సరిగ్గా.

609
00:41:44,000 --> 00:41:47,000
సోర్స్ కోడ్ మీరు నిజంగా అప్ టైప్ ఆ C స్మృతి.

610
00:41:47,000 --> 00:41:50,000
ఆబ్జెక్ట్ కోడ్ మీరు గణగణమని ద్వని చేయు నుండి పొందుతారు.

611
00:41:50,000 --> 00:41:54,000
ఇది ఆ బైనరీ ఫార్మాట్ 0 సె మరియు 1s ఉంది.

612
00:41:54,000 --> 00:41:59,000
మీరు వస్తువు ఫైళ్లు కొంత ఉన్నప్పుడు అప్పుడు ఏమి జరుగుతుందనే, ఉంది

613
00:41:59,000 --> 00:42:04,000
మీరు, ప్రాజెక్ట్ బహుళ సోర్స్ కోడ్ ఫైళ్ళను ఉపయోగించే ప్రోగ్రాం కంపైల్ చేస్తున్నారు అనుకోండి

614
00:42:04,000 --> 00:42:09,000
ఇది సాంప్రదాయకంగా. సి ఫైల్ పొడిగింపు ఇస్తారు.

615
00:42:09,000 --> 00:42:13,000
మేము caesar.c, vigenère.c ఎందుకు పేర్కొంది.

616
00:42:13,000 --> 00:42:18,000
మీరు Java కార్యక్రమాలు రాస్తున్నాం ఉంటే వాటిని మీరు పొడిగింపు ఇస్తుంది. జావా.

617
00:42:18,000 --> 00:42:24,000
పైథాన్ కార్యక్రమాలు పొడిగింపు కలిగి ఉంటాయి. Py తరచుగా.

618
00:42:24,000 --> 00:42:26,000
>> మీరు బహుళ. సి ఫైళ్లను కలిగి, మీరు వాటిని కంపైల్.

619
00:42:26,000 --> 00:42:29,000
గణగణమని ద్వని చేయు ఈ బైనరీ వ్యర్థ అన్ని ఉమ్మి వేస్తారు.

620
00:42:29,000 --> 00:42:33,000
మీరు మాత్రమే 1 ప్రోగ్రామ్ మీరు అప్పుడు ఎందుకంటే

621
00:42:33,000 --> 00:42:37,000
మీరు ఈ వస్తువు యొక్క అన్ని కలిసి ఫైల్స్ లింకర్ లింక్ను కలిగి

622
00:42:37,000 --> 00:42:40,000
1 ఎక్జిక్యూటబుల్ ఫైల్ లోకి.

623
00:42:40,000 --> 00:42:45,000
ఈ మీరు CS50 లైబ్రరీ ఉపయోగించేటప్పుడు ఏ ఉదాహరణకు, జరిగినప్పుడు కూడా ఉంది.

624
00:42:45,000 --> 00:42:50,000
CS50 లైబ్రరీ ఆ రెండూ. H శీర్షికా ఫైలును

625
00:42:50,000 --> 00:42:53,000
మీరు చదివే, # includecs50.h ఆ.

626
00:42:53,000 --> 00:42:58,000
అది కూడా ఒక ప్రత్యేక బైనరీ లైబ్రరీ ఫైల్

627
00:42:58,000 --> 00:43:02,000
ఆ, 0 సె మరియు 1s అని సంకలనం చేసిన

628
00:43:02,000 --> 00:43:08,000
మరియు ఆ-l జెండా, కాబట్టి మేము మా Spaces తిరిగి వెళ్ళి ఉంటే మేము నిజంగా త్వరగా చూడండి

629
00:43:08,000 --> 00:43:11,000
మేము మా గణగణమని ద్వని చేయు ఆదేశం చూస్తున్నప్పుడు ఇక్కడ ఏం జరగబోతోంది వద్ద,

630
00:43:11,000 --> 00:43:15,000
మనం పొందారు ఈ ఇక్కడే మా సోర్స్ కోడ్ ఫైలు ఉంది.

631
00:43:15,000 --> 00:43:18,000
ఈ కంపైలర్ జెండాలు కొంత ఉంటాయి.

632
00:43:18,000 --> 00:43:22,000
మరియు తర్వాత చాలా చివరిలో, ఈ-l జెండాలు లింక్ లో

633
00:43:22,000 --> 00:43:30,000
ఈ 2 గ్రంథాలయాల కోసం వాస్తవ బైనరీ ఫైళ్ళను, CS50 లైబ్రరీ మరియు తరువాత గణిత లైబ్రరీ.

634
00:43:30,000 --> 00:43:35,000
>> ఫైళ్ళను 'ప్రయోజనం ప్రతి రకం గ్రహించుట

635
00:43:35,000 --> 00:43:38,000
సంగ్రహం ప్రక్రియలో చెయ్యడానికి మీరు చేస్తాము విషయం

636
00:43:38,000 --> 00:43:43,000
కనీసం ఒక ఉన్నత స్థాయి అవగాహన కల్పించేందుకు.

637
00:43:43,000 --> 00:43:46,000
ఆబ్జెక్ట్ కోడ్ బయటకు వచ్చి సైన్ మూల కోడ్ వస్తుంది.

638
00:43:46,000 --> 00:43:53,000
ఆబ్జెక్ట్ కోడ్ ఫైళ్ళను కలిసి లింక్, మరియు మీరు ఒక అందమైన, అమలు ఫైల్.

639
00:43:53,000 --> 00:43:55,000
కూల్.

640
00:43:55,000 --> 00:43:58,000
మీరు బహుళ పాయింట్ల వద్ద లోపాలు పొందవచ్చు కూడా ఇక్కడే

641
00:43:58,000 --> 00:44:00,000
సంగ్రహం ప్రక్రియలో.

642
00:44:00,000 --> 00:44:04,000
ఈ పేరు, ఉదాహరణకు, మీరు ఈ లింక్ జెండాను తీసుకుంటే, ఉంది

643
00:44:04,000 --> 00:44:10,000
మీరు మీ కోడ్ అమలు చేసినప్పుడు CS50 జెండా మరియు మీరు, Spaces లో దీనిని మినహాయించడం లేదా

644
00:44:10,000 --> 00:44:13,000
మీరు, లింక్ దశలో లోపం పొందుతారు పేరు ఈ ఉంది

645
00:44:13,000 --> 00:44:18,000
మరియు లింకర్ హే, మీరు ఒక ఫంక్షన్ GetString అని ", పలుకును

646
00:44:18,000 --> 00:44:20,000
ఆ CS50 లైబ్రరీ ఉంది. "

647
00:44:20,000 --> 00:44:25,000
"అది మీరు CS50 లైబ్రరీ లో నాకు చెప్పారు, మరియు నేను కోసం కోడ్ దొరకదు."

648
00:44:25,000 --> 00:44:28,000
మీరు దానిని లింక్ కలిగి పేర్కొంది, మరియు ప్రత్యేక ఉంది

649
00:44:28,000 --> 00:44:33,000
ఒక కంపైలర్ లోపం నుండి కంపైలర్ సింటాక్స్ మరియు stuff ఆ రకమైన చూడటం ఎందుకంటే.

650
00:44:33,000 --> 00:44:38,000
ఇది ఉన్నప్పుడు ఏమి గుడ్ టు నో.

651
00:44:38,000 --> 00:44:42,000
>> ఇతర విషయాల గురించి తెలుసుకోవడానికి.

652
00:44:42,000 --> 00:44:49,000
నేను మీరు ఖచ్చితంగా జోర్డాన్ చేసిన ఒకే రకం పాత్రలు చేయడం న చిన్న పరిశీలించి అనుకుందాం చేస్తుంది

653
00:44:49,000 --> 00:44:55,000
ints హుడ్ కింద ఏమిటో అర్థం,

654
00:44:55,000 --> 00:44:58,000
హుడ్ కింద ఏ అక్షరాలు ఉంటాయి.

655
00:44:58,000 --> 00:45:02,000
మేము ASCII మాట్లాడే మరియు మేము నిజంగా ASCII పట్టిక చూస్తున్నప్పుడు,

656
00:45:02,000 --> 00:45:07,000
ఏమి ఏ హుడ్ దృష్టి మాకు ఒక అందిస్తున్న

657
00:45:07,000 --> 00:45:13,000
కంప్యూటర్ నిజానికి రాజధాని సూచిస్తుంది ఎలా వద్ద ఒక మరియు అంకెల 7

658
00:45:13,000 --> 00:45:17,000
మరియు కామాతో మరియు ఒక ప్రశ్న గుర్తు.

659
00:45:17,000 --> 00:45:20,000
కంప్యూటర్ కూడా ప్రాతినిధ్యం ప్రత్యేక మార్గాలను కలిగి ఉంది

660
00:45:20,000 --> 00:45:23,000
పూర్ణాంకం, సంఖ్య 7.

661
00:45:23,000 --> 00:45:27,000
ఇది ఒక ఫ్లోటింగ్ పాయింట్ సంఖ్యలు వంటి సంఖ్య 7 ప్రాతినిధ్యం ప్రత్యేక మార్గం ఉంది

662
00:45:27,000 --> 00:45:29,000
మరియు ఆ చాలా భిన్నంగా ఉంటాయి.

663
00:45:29,000 --> 00:45:32,000
ఒకే రకం పాత్రలు చేయడం మీరు కంప్యూటర్ "హే, నేను మీరు మార్చేందుకు మీరు చెప్పండి ఎలా ఉంది

664
00:45:32,000 --> 00:45:37,000
ఒక ప్రాతినిధ్యాన్ని మరొక ప్రాతినిధ్యం కు. "

665
00:45:37,000 --> 00:45:40,000
ఎందుకు మేము ఆ పరిశీలించి లేదు.

666
00:45:40,000 --> 00:45:44,000
>> నేను కూడా లైబ్రరీల మీద చిన్న మరియు కంపైలర్సును న చిన్న పరిశీలించి చేస్తుంది.

667
00:45:44,000 --> 00:45:47,000
సంకలనం యొక్క ప్రక్రియ గురించి ఆ చర్చ,

668
00:45:47,000 --> 00:45:53,000
ఏ ఒక గ్రంథాలయం, మరియు మీరు అడిగారు get అని ఈ ప్రశ్నలు కొన్ని వెళ్ళి.

669
00:45:53,000 --> 00:45:55,000
వీక్ 1 అంశంపై ప్రశ్నలు?

670
00:45:55,000 --> 00:46:03,000
మీరు కవర్ చేయడానికి కావలసిన వీరిని కనిపించే ఇక్కడ ఏ అంశాలు ఉన్నాయి?

671
00:46:03,000 --> 00:46:07,000
మేము ను విధంగా నేను ఈ ప్రారంభ విషయాల నుంచి వీచడం దీనికై

672
00:46:07,000 --> 00:46:13,000
గమనికలు మరియు సూత్రం యొక్క ఏమి కొద్దిగా.

673
00:46:13,000 --> 00:46:15,000
ఆలోచనలు?

674
00:46:15,000 --> 00:46:19,000
కవర్ చేయడానికి ఏదైనా?

675
00:46:19,000 --> 00:46:21,000
బహుశా కొన్ని చాక్లెట్ కోసం సమయం?

676
00:46:21,000 --> 00:46:23,000
మీరు అబ్బాయిలు ఇది ద్వారా కృషి చేస్తున్నారు.

677
00:46:23,000 --> 00:46:26,000
నా కాఫీ లో sipping ఉంచడానికి వెళుతున్న.

678
00:46:26,000 --> 00:46:31,000
2 వ వారం.

679
00:46:31,000 --> 00:46:34,000
గుడ్ కాల్, మంచి కాల్.

680
00:46:34,000 --> 00:46:38,000
వీక్ 2 మేము విధులు గురించి కొద్దిగా ఎక్కువ మాట్లాడారు.

681
00:46:38,000 --> 00:46:43,000
>> మొదటి కొన్ని సమస్య సెట్లలో మేము నిజంగా ఎలాంటి విధులు రాయడానికి లేదు

682
00:46:43,000 --> 00:46:45,000
ఇది ఫంక్షన్ కంటే ఇతర?

683
00:46:45,000 --> 00:46:47,000
సరిగ్గా [స్టూడెంట్] ప్రధాన. >> ప్రధాన.

684
00:46:47,000 --> 00:46:51,000
కాబట్టి మేము ప్రధాన ధరిస్తుంది వివిధ దుస్తులను చూసిన.

685
00:46:51,000 --> 00:46:54,000
అది ఎటువంటి వాదనలూ లేవు పడుతుంది దీనిలో ఒక ఉన్నది

686
00:46:54,000 --> 00:46:58,000
మరియు మేము, వాక్యాల మధ్య లో తప్ప సే

687
00:46:58,000 --> 00:47:01,000
తరువాత, మేము ఆదేశ పంక్తి వాదనలు తీసుకోవాలని అనుకుంటున్నారు పేరు ఇతర ఒక ఉంది

688
00:47:01,000 --> 00:47:08,000
మీరు Int argc మరియు స్ట్రింగ్ argv శ్రేణి కలిగి ఉన్న మరియు మేము చూసిన వంటి, ఆ

689
00:47:08,000 --> 00:47:13,000
లేదా ఇప్పుడు మేము నిజానికి అది చార్ * అని స్ట్రింగ్ బహిర్గతం చేసిన

690
00:47:13,000 --> 00:47:20,000
మేము చార్ * argv మరియు తరువాత బ్రాకెట్లలో గా రాయటం మొదలుపెట్టాలని వెళుతున్న.

691
00:47:20,000 --> 00:47:22,000
సమస్య సెట్ 3, మీరు అబ్బాయిలు, ఫంక్షన్స్ కొంత చూసిన

692
00:47:22,000 --> 00:47:27,000
మరియు మీరు విధులను కొంత అమలు, డ్రా, పెనుగులాట వెతకండి.

693
00:47:27,000 --> 00:47:31,000
నమూనాలను అన్ని మీరు అక్కడ రాశారు.

694
00:47:31,000 --> 00:47:33,000
>> నేను నిజంగా త్వరగా విధులు ఇక్కడ మాట్లాడటానికి అనుకున్నవే

695
00:47:33,000 --> 00:47:38,000
మీరు ఒక ఫంక్షన్ వ్రాయండి చేసినప్పుడు 3 భాగాలు వారికి ఉన్నాయి ఉంది.

696
00:47:38,000 --> 00:47:43,000
మీరు ఫంక్షన్ తిరిగి టైప్ పేర్కొనాలి.

697
00:47:43,000 --> 00:47:46,000
మీరు ఫంక్షన్కు ఒక పేరు పేర్కొనాలి, ఆపై మీరు పేర్కొనాలి

698
00:47:46,000 --> 00:47:51,000
వాదన జాబితా లేదా పారామితి జాబితా.

699
00:47:51,000 --> 00:47:57,000
ఉదాహరణకు, నేను పూర్ణాంకాల యొక్క బంచ్ అప్ మొత్తానికి ఒక ఫంక్షన్ రాయడానికి ఉన్నాయి

700
00:47:57,000 --> 00:48:03,000
తరువాత నాకు నా తిరిగి టైప్ అంటే ఏమిటో మొత్తం తిరిగి

701
00:48:03,000 --> 00:48:06,000
నేను పూర్ణ మొత్తం మరియు తరువాత మొత్తం తిరిగి కోరారు? ఉంటే

702
00:48:06,000 --> 00:48:12,000
అప్పుడు ఆ చర్య యొక్క పేరును.

703
00:48:12,000 --> 00:48:27,000
నేను ముందుకు వెళ్లి గ్రీన్ వ్రాస్తే, ఈ భాగాన్ని రకం.

704
00:48:27,000 --> 00:48:34,000
ఈ భాగం పేరు.

705
00:48:34,000 --> 00:48:40,000
ఆపై వాక్యాల మధ్య లో

706
00:48:40,000 --> 00:48:46,000
నేను వాదనలు ఇవ్వాలని పేరు ఉంది

707
00:48:46,000 --> 00:48:56,000
తరచుగా కొన్నిసార్లు పారామితులు కోసం పరామితులు అని ARGS, క్లుప్తంగా.

708
00:48:56,000 --> 00:49:00,000
మీకు ఒకటి ఉంటే మీరు కేవలం ఒక తెలుపుము.

709
00:49:00,000 --> 00:49:06,000
మీరు బహుళ ఉంటే మీరు కామాతో ప్రతి ఒక వేరు.

710
00:49:06,000 --> 00:49:13,000
మరియు ప్రతి వాదన కోసం మీరు 2 విషయాలు ఇస్తున్న ఉంటాయి-కెవిన్?

711
00:49:13,000 --> 00:49:18,000
[కెవిన్] మీరు టైప్ చేసి, ఆపై పేరు ఇవ్వాల్సి ఉంటుంది.

712
00:49:18,000 --> 00:49:21,000
ఆపై పేరు, మరియు పేరు మీరు ఉపయోగించే చూడాలని ఉద్దేశ్యంతో పేరు

713
00:49:21,000 --> 00:49:25,000
మొత్తం ఫంక్షన్ లో ఆ వాదన సూచించడానికి,

714
00:49:25,000 --> 00:49:27,000
మీరు ప్రస్తుతం రాస్తున్నాం ఫంక్షన్ లో.

715
00:49:27,000 --> 00:49:32,000
>> మీరు, నేను సంకలనం వెళుతున్న ఉంటే, ఉదాహరణకు నుండి కోసం లేదు

716
00:49:32,000 --> 00:49:41,000
పూర్ణాంకాల-we'll యొక్క వ్యూహం Int శ్రేణి చేయండి సే,,

717
00:49:41,000 --> 00:49:46,000
మరియు నేను కొన్ని వంకర జంట కలుపులు ఇస్తాము అక్కడ-

718
00:49:46,000 --> 00:49:51,000
నేను మొత్తం కు వ్యూహం పాస్ అప్పుడు

719
00:49:51,000 --> 00:49:55,000
నేను వాదన జాబితా యొక్క మొదటి స్థానం లో పాస్.

720
00:49:55,000 --> 00:49:59,000
కానీ నేను వెళ్ళే శ్రేణి పేరు చేరే సమయం కలిగి లేదు.

721
00:49:59,000 --> 00:50:07,000
చేరే సమయం నేను పనితీరు శరీరం లోపల ఆ వాదన చూడండి ఎలా ఉండబోతుంది.

722
00:50:07,000 --> 00:50:10,000
మేము పరిగణనలోకి తీసుకోవాలని అవసరమైన ఇతర విషయం,

723
00:50:10,000 --> 00:50:14,000
మరియు ఈ పనులను కొంచెం వ్యత్యాసంగా ఉంటుంది, కాని నేను ఇది ఒక ముఖ్యమైన స్థానం అని

724
00:50:14,000 --> 00:50:20,000
సి లో నేను ఈ వంటి ఒక ఫంక్షన్ రాయడం ఉన్నపుడు ఆ

725
00:50:20,000 --> 00:50:29,000
ఎలా నేను ఈ శ్రేణి లో ఎన్ని అంశాలు తెలుసు?

726
00:50:29,000 --> 00:50:31,000
ఈ ఒక ట్రిక్ ప్రశ్న కొంతవరకు ఉంది.

727
00:50:31,000 --> 00:50:35,000
మేము గత వారం యొక్క విభాగంలో ఈ గురించి కొద్దిగా మాట్లాడారు.

728
00:50:35,000 --> 00:50:40,000
నేను సి ఒక శ్రేణిలో మూలకాల సంఖ్య తెలుసు?

729
00:50:40,000 --> 00:50:44,000
ఒక మార్గం ఉంది?

730
00:50:44,000 --> 00:50:49,000
>> ఇది తెలిసిన మార్గం లేదు అని అవుతుంది.

731
00:50:49,000 --> 00:50:52,000
మీరు ప్రత్యేకంగా లో ఉత్తీర్ణత సాధించవలసి ఉంటుంది.

732
00:50:52,000 --> 00:50:55,000
మీరు చేయవచ్చు ఒక ట్రిక్ ఉంది

733
00:50:55,000 --> 00:51:00,000
మీరు శ్రేణి డిక్లేర్డ్ ఉంది అదే ఫంక్షన్ లో అయితే

734
00:51:00,000 --> 00:51:04,000
మరియు మీరు ఒక స్టాక్ శ్రేణి తో పని చేస్తున్నాము.

735
00:51:04,000 --> 00:51:06,000
మీరు అదే ఫంక్షన్ లో అయితే కానీ మాత్రమే పనిచేస్తుంది.

736
00:51:06,000 --> 00:51:09,000
మీరు మరొక కు వ్యూహం పాస్ లేదా మీరు వ్యూహం డిక్లేర్డ్ ఉంటే

737
00:51:09,000 --> 00:51:12,000
మరియు మీరు కుప్ప ఆ శ్రేణి ఉంచారు, మీరు malloc ఉపయోగించి

738
00:51:12,000 --> 00:51:15,000
 మరియు వాటిలో ఆ విధమైన, అప్పుడు అన్ని పందెం ఆఫ్ ఉంటాయి.

739
00:51:15,000 --> 00:51:18,000
అప్పుడు మీరు నిజంగా చుట్టూ పాస్ కలిగి

740
00:51:18,000 --> 00:51:21,000
ప్రత్యేక వాదన లేదా మరొక పారామితి

741
00:51:21,000 --> 00:51:23,000
శ్రేణి ఎంత పెద్ద మీరు చెప్పటం.

742
00:51:23,000 --> 00:51:28,000
ఈ సందర్భంలో, నేను క్షమించండి, తెరపై జరగబోతోంది కామాతో I'm ఉపయోగించాలనుకుంటున్నాను భావిస్తున్న ఇక్కడ

743
00:51:28,000 --> 00:51:32,000
మరియు నేను మరొక వాదన లో పాస్ కావలసిన

744
00:51:32,000 --> 00:51:40,000
 మరియు అది పొడవు కోసం Int లెన్ కాల్.

745
00:51:40,000 --> 00:51:44,000
>> క్విజ్ లో రావచ్చు ఒక్క విషయము

746
00:51:44,000 --> 00:51:49,000
అని ఒక నిర్దిష్ట విధిని రాయడం లేదా అమలు మీరు అడుగుతున్నారు.

747
00:51:49,000 --> 00:51:54,000
మేము మీరు నమూనా ఇవ్వాలని లేదు ఉంటే, ఇక్కడ ఈ మొత్తం విషయం,

748
00:51:54,000 --> 00:51:58,000
ఈ మొత్తం మెస్, ఫంక్షన్ ప్రకటన లేదా చర్య నమూనా అని పిలుస్తారు

749
00:51:58,000 --> 00:52:01,000
ఈ ఇచ్చిన చేయకపోతే మీరు డౌన్ గోరు చెయ్యవచ్చును మొదటి విషయాలు ఒకటి

750
00:52:01,000 --> 00:52:03,000
వెంటనే క్విజ్ మీకు.

751
00:52:03,000 --> 00:52:06,000
నేను తెలుసుకున్న చేసిన ఇతర ట్రిక్ అని

752
00:52:06,000 --> 00:52:11,000
మేము మీరు ఒక వేడుకలో ఒక నమూనా ఇవ్వాలని చెప్పే, మరియు మేము సే, "హే, మీరు వ్రాయుటకు పొందారు."

753
00:52:11,000 --> 00:52:16,000
మీరు క్విజ్ లో కలిగి ఆ గిరజాల జంట కలుపులు ఇన్సైడ్

754
00:52:16,000 --> 00:52:20,000
మీరు తిరిగి టైప్ లేదు అని గమనించి మరియు మీరు గమనిస్తే ఆ తిరిగి రకం

755
00:52:20,000 --> 00:52:25,000
ఫంక్షన్ ఏదైనా తిరిగి అర్థం కాదు ఇది తప్ప, కంటే ఇతర ఏదైనా, ఉంది

756
00:52:25,000 --> 00:52:28,000
అప్పుడు మీరు ఖచ్చితంగా చేయాలనుకుంటున్నారా ఒక విషయం వ్రాయడానికి ఉంది

757
00:52:28,000 --> 00:52:33,000
ఫంక్షన్ యొక్క చివరిలో తిరిగి ప్రకటన విధమైన.

758
00:52:33,000 --> 00:52:40,000
మేము ఖాళీ పూరించడానికి కావలసిన ఎందుకంటే రిటర్న్, మరియు ఈ సందర్భంలో, మనం ఖాళీ ఉంచుతాము.

759
00:52:40,000 --> 00:52:44,000
కానీ ఈ మీరు ఎలా ఈ సమస్య చేరుకోవటానికి నేను గురించి సరైన విధంగా ఆలోచిస్తూ గెట్స్?

760
00:52:44,000 --> 00:52:49,000
మరియు మీరు ఒక విలువను తిరిగి చూడాలని మీరు గుర్తు

761
00:52:49,000 --> 00:52:51,000
పనితీరు కాలర్కు.

762
00:52:51,000 --> 00:52:54,000
>> అవును. >> [స్టూడెంట్] మేము క్విజ్ న కోడ్ వ్రాస్తున్నప్పుడు శైలి వర్తిస్తుంది?

763
00:52:54,000 --> 00:52:58,000
ఇండెంటేషన్ని మరియు stuff ఆ రకమైన వంటి? >> [స్టూడెంట్] అవును.

764
00:52:58,000 --> 00:53:00,000
కాదు, కాదు చాలా.

765
00:53:00,000 --> 00:53:09,000
నేను, ఈ-చాలా మేము రోజు క్విజ్ న స్పష్టం చేస్తాము ఏదో భావిస్తే

766
00:53:09,000 --> 00:53:15,000
కానీ సాధారణంగా గురించి చింతిస్తూ # కలిగి మరియు stuff ఆ రకమైన, ఇది బయట యొక్క ఉంటాము.

767
00:53:15,000 --> 00:53:17,000
[స్టూడెంట్] మీరు మీ చేతితో రాసిన కోడ్ మీరే చెయ్యాలి?

768
00:53:17,000 --> 00:53:19,000
మీ చేతితో రాసిన కోడ్ మీరే చెయ్యాలి?

769
00:53:19,000 --> 00:53:24,000
మీరు పాక్షిక క్రెడిట్ గురించి ఆందోళన మీరు వ్యాఖ్యానిస్తూ ఎప్పుడూ మంచిది

770
00:53:24,000 --> 00:53:29,000
లేదా మీరు grader మీ ఉద్దేశం కమ్యూనికేట్ మీరు.

771
00:53:29,000 --> 00:53:33,000
కానీ నేను, మళ్ళీ, క్విజ్ పైనే మరియు క్విజ్ రోజు స్పష్టం చేస్తుంది

772
00:53:33,000 --> 00:53:39,000
కానీ నేను మీకు, వ్యాఖ్యలు రాయడం చేయాలి ఉందని విశ్వసించడం లేదు.

773
00:53:39,000 --> 00:53:42,000
సాధారణంగా, కానీ ఖచ్చితంగా విషయం యొక్క విధమైన కాదు పేరు

774
00:53:42,000 --> 00:53:45,000
మీరు, మీ ఉద్దేశం కమ్యూనికేట్ "నేను తో వెళుతున్న పేరు హే, ఇది ఉంది."

775
00:53:45,000 --> 00:53:49,000
మరియు కొన్నిసార్లు పాక్షిక క్రెడిట్ తో సహాయపడే.

776
00:53:49,000 --> 00:53:51,000
కూల్.

777
00:53:51,000 --> 00:53:53,000
>> బాసిల్.

778
00:53:53,000 --> 00:53:56,000
[బాసిల్] Int lang సే, ప్రకటించే మధ్య తేడా ఏమిటి

779
00:53:56,000 --> 00:54:03,000
ఫంక్షన్ ఒక వేరియబుల్ ప్రకటించారు వర్సెస్ వాదనలు లేదా పారామితులు లో?

780
00:54:03,000 --> 00:54:05,000
వావ్, కాఫీ గాలివాహిక మరణించింది.

781
00:54:05,000 --> 00:54:07,000
[బాసిల్] మేము వాదనలు ఉంచారు కోరుకుంటున్న విషయాలు ఇష్టపడుతున్నారు.

782
00:54:07,000 --> 00:54:09,000
అవును, ఒక గొప్ప ప్రశ్న.

783
00:54:09,000 --> 00:54:11,000
ఎలా మీరు వాదనలు అందించేందుకు ఏమి విషయాలు ఎంచుకుంటే

784
00:54:11,000 --> 00:54:17,000
మీరు ఫంక్షన్ లోపలి చెయ్యాలి విషయాలు వర్సెస్?

785
00:54:17,000 --> 00:54:24,000
ఈ సందర్భంలో మనం వాదనలు ఈ రెండు ఉన్నాయి

786
00:54:24,000 --> 00:54:29,000
వారు మొత్తం క్రియాశీలతను ఉపయోగించదు అన్నారు ఎవరైతే ఏదో ఉన్నారు ఎందుకంటే

787
00:54:29,000 --> 00:54:32,000
ఆ విషయాలు తెలుపుము అవసరం.

788
00:54:32,000 --> 00:54:35,000
>> మొత్తం ఫంక్షన్, మేము గురించి మాట్లాడారు వంటి తెలుసుకోవడం కాదు ఉంది

789
00:54:35,000 --> 00:54:40,000
తన కాలర్ లేదా ఎవరైతే నుండి పొందుతుంది ఎంత పెద్ద శ్రేణి మొత్తం ఫంక్షన్ ఉపయోగిస్తోంది.

790
00:54:40,000 --> 00:54:44,000
ఇది ఆ శ్రేణి ఎంత పెద్ద తెలుసుకోవడం కాదు ఉంది.

791
00:54:44,000 --> 00:54:48,000
మేము ఒక వాదన గా ఇక్కడే ఈ పొడవు పాస్ కారణం

792
00:54:48,000 --> 00:54:51,000
మేము ప్రధానంగా, పనితీరు కాలర్ చెప్పుకుంటున్నారు ఏదో ఎందుకంటే ఉంది

793
00:54:51,000 --> 00:54:55,000
మొత్తం క్రియాశీలతను ఉపయోగించదు అన్నారు ఎవరైతే, "హే, మీరు మాకు వ్యూహం ఇవ్వాలని ఉన్నాయి మాత్రమే

794
00:54:55,000 --> 00:54:59,000
ints యొక్క, మీరు కూడా ఎంత పెద్ద మీరు మాకు ఇచ్చిన చేసిన శ్రేణి మాకు అవసరం. "

795
00:54:59,000 --> 00:55:03,000
[బాసిల్] ఆ రెండు ఆదేశ పంక్తి వాదనలు ఉంటుంది?

796
00:55:03,000 --> 00:55:06,000
లేదు, ఈ మీరు ఫంక్షన్ కు చేరుతుందని నిజమైన వాదనలు.

797
00:55:06,000 --> 00:55:10,000
>> నాకు ఇక్కడ ఒక కొత్త పేజీ తెలియజేసేలా.

798
00:55:10,000 --> 00:55:13,000
[బాసిల్] పేరు ఇలా ఉత్తీర్ణత చేస్తుంది

799
00:55:13,000 --> 00:55:24,000
[నేట్ H.] నేను Int ప్రధాన ఉంటే (తప్ప),

800
00:55:24,000 --> 00:55:27,000
మరియు నేను, దిగువన ఇక్కడ నేను తిరిగి 0 లో అణిచివేసేందుకు వెళుతున్న

801
00:55:27,000 --> 00:55:31,000
మరియు నేను మొత్తం ఫంక్షన్ కాల్ అనుకుందాం.

802
00:55:31,000 --> 00:55:42,000
నేను చెప్పాలనుకోవడం Int x = మొత్తం ();

803
00:55:42,000 --> 00:55:46,000
మొత్తం ఫంక్షన్ ఉపయోగించేందుకు నేను అప్ సంకలనం చేయదలిచిన రెండు శ్రేణి లో ఉత్తీర్ణత సాధించవలసి ఉంటుంది

804
00:55:46,000 --> 00:55:51,000
యెరే యొక్క పొడవు, కాబట్టి ఈ పేరు ఉంది

805
00:55:51,000 --> 00:55:54,000
నేను, ints యొక్క వ్యూహం కలిగి ఊహించండి

806
00:55:54,000 --> 00:56:12,000
నేను కలిగి చెప్పేది Int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
అక్కడే సింటాక్స్ అప్ హ్యాక్ ఉపయోగించడం రకం,

808
00:56:16,000 --> 00:56:21,000
అప్పుడు నేను ఉంటుంది మొత్తం లో నేను పాస్ అనుకుంటున్నారో

809
00:56:21,000 --> 00:56:27,000
numbaz మరియు సంఖ్య 3 రెండు

810
00:56:27,000 --> 00:56:30,000
"సరే, ఇక్కడ నేను మీరు సంకలనం చేయదలిచిన శ్రేణి ఉంది." మొత్తం ఫంక్షన్ చెప్పడం

811
00:56:30,000 --> 00:56:34,000
"ఇక్కడ దాని పరిమాణం ఉంటుంది."

812
00:56:34,000 --> 00:56:39,000
ఆ సమంజసం లేదు? మీ ప్రశ్నకు సమాధానం ఉందా?

813
00:56:39,000 --> 00:56:42,000
>> పలు రకాలుగా మనం ప్రధాన తో చేయడం ఏమి సమాంతర చేస్తుంది

814
00:56:42,000 --> 00:56:44,000
మేము ఆదేశ పంక్తి వాదనలు ఉన్నప్పుడు.

815
00:56:44,000 --> 00:56:47,000
సీజర్ సాంకేతికలిపి వంటి ఒక ప్రోగ్రామ్, ఉదాహరణకు, ఆ అవసరం

816
00:56:47,000 --> 00:56:53,000
ఆదేశ పంక్తి వాదనలు ఏదైనా చేస్తామని కాదు.

817
00:56:53,000 --> 00:56:57,000
మీరు ఏ కీ ఉపయోగించడానికి చెప్పలేదు అది గుప్తీకరించడానికి ఎలా అర్థం కాదు

818
00:56:57,000 --> 00:57:03,000
లేదా మీరు గుప్తీకరించడానికి అనుకున్నవే స్ట్రింగ్ అది చెప్పరు ఉంటే.

819
00:57:03,000 --> 00:57:08,000
మేము 2 విభిన్న పద్దతులను పొందారు పేరు ఇన్పుట్ కోసం ప్రాంప్ట్, ఈ ఉంది

820
00:57:08,000 --> 00:57:14,000
యూజర్ నుండి సమాచారం తీసుకుని వినియోగదారు నుండి ఇన్పుట్ తీసుకుని.

821
00:57:14,000 --> 00:57:19,000
సమస్య 1 కోసం మేము ఈ GetInt, GetString, GetFloat విధంగా చూసిన

822
00:57:19,000 --> 00:57:26,000
ఇన్పుట్ కోసం ప్రాంప్ట్ యొక్క, మరియు ప్రామాణిక ఇన్పుట్ స్ట్రీమ్ ఉపయోగించి అని.

823
00:57:26,000 --> 00:57:28,000
ఇది కొద్దిగా భిన్నంగా ఉంటుంది.

824
00:57:28,000 --> 00:57:31,000
ఇది వ్యతిరేకంగా మీరు ఒక సమయంలో విషయం యొక్క

825
00:57:31,000 --> 00:57:35,000
మీరు ప్రోగ్రామ్ను అమలు ప్రారంభించిన మీరు ప్రోగ్రామ్, ఇన్వోక్ ఉన్నప్పుడు.

826
00:57:35,000 --> 00:57:41,000
మీరు ప్రోగ్రామ్ను అమలు ప్రారంభించిన ఆదేశ పంక్తి వాదనలు అన్ని పేర్కొంటారు.

827
00:57:41,000 --> 00:57:47,000
మేము ఆ రెండు మిక్సింగ్ చేసిన.

828
00:57:47,000 --> 00:57:52,000
మేము ఒక ఫంక్షన్ కు వాదనలు ఉపయోగించినప్పుడు, అది చాలా ముఖ్య కు ఆదేశ పంక్తి వాదనలు వంటిది.

829
00:57:52,000 --> 00:57:56,000
మీరు చెప్పడం అవసరం ఫంక్షన్ అర్థించడానికి ఉన్నప్పుడు ఇది

830
00:57:56,000 --> 00:58:05,000
తన పనులు అమలు చేయడానికి అవసరం సరిగ్గా అదే.

831
00:58:05,000 --> 00:58:08,000
, వద్ద మరియు చూడటానికి నేను మీరు మీ ఖాళీ సమయంలో అది చూద్దాం చేస్తాము మరో మంచి విషయం

832
00:58:08,000 --> 00:58:11,000
మరియు అది లో కవర్ జరిగినది స్కోప్ యొక్క ఈ భావన క్విజ్-ఉంది

833
00:58:11,000 --> 00:58:15,000
మరియు ప్రపంచ వేరియబుల్స్ వర్సెస్ స్థానిక వేరియబుల్స్.

834
00:58:15,000 --> 00:58:18,000
కు శ్రద్ద చేయండి.

835
00:58:18,000 --> 00:58:23,000
>> మేము, ఈ ఇతర స్టఫ్ న చేస్తున్నారు ఇప్పుడు ఆ

836
00:58:23,000 --> 00:58:27,000
3 వ వారం లో మేము శోధించడం మరియు క్రమబద్ధీకరించేందుకు గురించి మాట్లాడటం మొదలుపెట్టాడు.

837
00:58:27,000 --> 00:58:32,000
, కనీసం CS50 లో, శోధిస్తోంది మరియు క్రమబద్ధీకరించేందుకు

838
00:58:32,000 --> 00:58:39,000
చాలా కంప్యూటర్ సైన్స్, మరింత సైద్ధాంతిక భాగాలు కొన్ని పరిచయం ఉంది.

839
00:58:39,000 --> 00:58:42,000
శోధన యొక్క సమస్య, సార్టింగ్ యొక్క సమస్య

840
00:58:42,000 --> 00:58:46,000
పెద్ద, కానానికల్ సమస్యలు.

841
00:58:46,000 --> 00:58:52,000
ఎలా మీరు పూర్ణాంకాల బిలియన్ల యొక్క వ్యూహం ఒక నిర్దిష్ట సంఖ్య కనుక్కుంటారు?

842
00:58:52,000 --> 00:58:55,000
ఎలా మీరు ఒక ఫోన్ బుక్ లోపల ఒక ప్రత్యేక పేరు కనుగొనగలను

843
00:58:55,000 --> 00:58:59,000
మీ ల్యాప్టాప్ న నిల్వ?

844
00:58:59,000 --> 00:59:04,000
కాబట్టి మేము asymptotic పరుగుల సార్లు ఈ భావన పరిచయం

845
00:59:04,000 --> 00:59:11,000
నిజంగా ఎంత, ఈ సమస్య ఎలా కష్టం పరిగణించడం,

846
00:59:11,000 --> 00:59:14,000
ఎంత వారు పరిష్కరించడానికి తీసుకుని.

847
00:59:14,000 --> 00:59:20,000
2011 యొక్క క్విజ్, నేను అనుకున్నట్లుగా, నేను మెరిట్లతో భావిస్తున్న ఒక సమస్య ఉంది

848
00:59:20,000 --> 00:59:27,000
ఈ ఒక, సమస్య 12 ఇది చాలా త్వరగా కవర్.

849
00:59:27,000 --> 00:59:32,000
ఏ O, అది ఒమేగా ఉంది.

850
00:59:32,000 --> 00:59:41,000
>> ఇక్కడ మేము సాధ్యమైనంత వేగ పరుగుల సమయం గురించి మాట్లాడటం మీరు

851
00:59:41,000 --> 00:59:46,000
ఒక నిర్దిష్ట అల్గోరిథం మరియు అప్పుడు నెమ్మదిగా సాధ్యం రన్ టైం.

852
00:59:46,000 --> 00:59:52,000
ఈ ఒమేగా మరియు O నిజంగా కేవలం సత్వరమార్గాలు ఉన్నాయి.

853
00:59:52,000 --> 00:59:55,000
వారు చెప్పే సంజ్ఞామాన సత్వరమార్గాలు ఉన్నారు

854
00:59:55,000 --> 00:59:59,000
ఎంత వేగంగా ఉత్తమ కేసులో రెడీ మా అల్గోరిథం పరుగుల,

855
00:59:59,000 --> 01:00:06,000
మరియు ఎలా చెత్త సాధ్యం కేసులో నెమ్మదిగా మా అల్గోరిథం రన్ చేస్తుంది?

856
01:00:06,000 --> 01:00:10,000
ఈ రెండు చేయండి యొక్క లెట్, మరియు ఈ కూడా కప్పబడి ఉన్నాయి

857
01:00:10,000 --> 01:00:13,000
నేను అత్యంత సిఫార్సు ఇది asymptotic నోటేషన్ న చిన్న లో.

858
01:00:13,000 --> 01:00:17,000
జాక్సన్ మంచి ఉద్యోగం చేసాడు.

859
01:00:17,000 --> 01:00:23,000
బైనరీ శోధనతో, మేము, ఒక అల్గోరిథం గా బైనరీ శోధన మాట్లాడటానికి

860
01:00:23,000 --> 01:00:28,000
మరియు మేము సాధారణంగా పెద్ద ఓ పరంగా దాని గురించి మాట్లాడటానికి

861
01:00:28,000 --> 01:00:30,000
పెద్ద O ఏమిటి?

862
01:00:30,000 --> 01:00:34,000
బైనరీ శోధన తక్కువ వేగంతో సాధ్యం రన్ టైం అంటే ఏమిటి?

863
01:00:34,000 --> 01:00:36,000
[స్టూడెంట్] N ²?

864
01:00:36,000 --> 01:00:41,000
క్లోజ్, నేను ఆ ఊహించడం.

865
01:00:41,000 --> 01:00:43,000
ఇది చాలా వేగంగా కంటే ఉంది.

866
01:00:43,000 --> 01:00:45,000
[స్టూడెంట్] బైనరీ? >> అవును, బైనరీ శోధన.

867
01:00:45,000 --> 01:00:47,000
[స్టూడెంట్] ఇది లాగ్ n ఉంది.

868
01:00:47,000 --> 01:00:49,000
లాగిన్ n ఏమి అర్ధం కాబట్టి, n ప్రవేశించండి?

869
01:00:49,000 --> 01:00:51,000
ఇది ప్రతి పునరావృతం విభజించటం.

870
01:00:51,000 --> 01:00:56,000
సరిగ్గా, కాబట్టి నెమ్మదిగా సాధ్యం సందర్భంలో,

871
01:00:56,000 --> 01:01:00,000
మీరు ఒక క్రమబద్ధీకరించబడతాయి శ్రేణి ఉంటే చెప్పండి

872
01:01:00,000 --> 01:01:08,000
ఒక మిలియన్ పూర్ణాంకాల మరియు సంఖ్య మీరు చూస్తున్న

873
01:01:08,000 --> 01:01:14,000
గాని యెరే నందలి శ్రేణి లేదా ఆఖరి మూలకం లో మొట్టమొదటి అంశం.

874
01:01:14,000 --> 01:01:18,000
గుర్తుంచుకోండి, బైనరీ శోధన అల్గోరిథం, మధ్య మూలకం చూడటం ద్వారా పనిచేస్తుంది

875
01:01:18,000 --> 01:01:21,000
మీరు వెతికే మ్యాచ్ లేదో చూడటం.

876
01:01:21,000 --> 01:01:23,000
అది గొప్ప ఉంటే, మీరు కనుగొన్నారు.

877
01:01:23,000 --> 01:01:27,000
>> ఉత్తమ సందర్భంలో, ఎంత వేగంగా బైనరీ శోధన పరుగుల చేస్తుంది?

878
01:01:27,000 --> 01:01:29,000
[స్టూడెంట్స్] 1.

879
01:01:29,000 --> 01:01:32,000
1, అది, 1 పెద్ద O స్థిరంగా సమయం. అవును.

880
01:01:32,000 --> 01:01:36,000
[స్టూడెంట్] నేను ఒక ప్రశ్న కలిగి ఉంటాయి. మీరు n యొక్క లాగిన్ చెప్పినప్పుడు మీరు కుడి, బేస్ 2 సంబంధించి అర్థం?

881
01:01:36,000 --> 01:01:40,000
అవును, కాబట్టి ఇతర విషయం.

882
01:01:40,000 --> 01:01:44,000
మేము లాగ్ n, మరియు నేను హై స్కూల్ లో ఉన్నప్పుడు, నాకు ఊహించడం

883
01:01:44,000 --> 01:01:48,000
నేను ఎల్లప్పుడూ log బేస్ 10 భావించి.

884
01:01:48,000 --> 01:01:57,000
అవును, అవును అలా, బేస్ 2 సాధారణంగా మేము ఉపయోగం ఏమిటి లాగిన్ అవ్వండి.

885
01:01:57,000 --> 01:02:02,000
మీరు శోధిస్తున్న మళ్లీ,, బైనరీ శోధన తిరిగి వెళ్ళడం

886
01:02:02,000 --> 01:02:05,000
చివరిలో మూలకం లేదా చాలా ప్రారంభంలో మూలకం,

887
01:02:05,000 --> 01:02:08,000
మీరు మధ్య ప్రారంభం మరియు ఎందుకంటే అప్పుడు మీరు తొలగించాలనుకుంటున్నారా

888
01:02:08,000 --> 01:02:13,000
కావాల్సిన సగం మీరు వెతికే ప్రమాణాలను చేరుకోలేదు,

889
01:02:13,000 --> 01:02:15,000
మరియు మీరు తరువాతి అర్ధ మరియు తరువాతి అర్ధ మరియు తరువాతి అర్ధ వెళ్ళండి.

890
01:02:15,000 --> 01:02:19,000
నేను మిలియన్ పూర్ణాంక శ్రేణి అతిపెద్ద మూలకం కోసం శోధించడం నేను ఉంటే

891
01:02:19,000 --> 01:02:25,000
నేను 1 మిలియన్ రెట్లు ఎక్కువ లాగ్ వద్ద సగానికి వెళుతున్న

892
01:02:25,000 --> 01:02:28,000
చివరికి నేను పరీక్షించడానికి మరియు మూలకం నేను చూస్తున్నాను ఆ చూడండి ముందు

893
01:02:28,000 --> 01:02:33,000
, అతిపెద్ద లేదా శ్రేణి యొక్క అత్యధిక ఇండెక్స్ లో ఉంది

894
01:02:33,000 --> 01:02:38,000
మరియు ఆ 1 మిలియన్ సార్లు లాగిన్ n యొక్క లాగ్ పడుతుంది.

895
01:02:38,000 --> 01:02:40,000
>> బబుల్ సార్ట్.

896
01:02:40,000 --> 01:02:43,000
మీరు అబ్బాయిలు బబుల్ సార్ట్ అల్గోరిథం గుర్తు లేదా?

897
01:02:43,000 --> 01:02:47,000
కెవిన్, మీరు నాకు బబుల్ సార్ట్ అల్గోరిథం లో జరిగినదాని యొక్క శీఘ్ర రీక్యాప్ ఇస్తుంది?

898
01:02:47,000 --> 01:02:50,000
[కెవిన్] సహజంగా జాబితాలో ప్రతిదీ ద్వారా వెళుతుంది.

899
01:02:50,000 --> 01:02:52,000
ఇది మొదటి రెండు వద్ద ఉంది.

900
01:02:52,000 --> 01:02:55,000
మొదటి ఒక రెండవ దానిని మార్పిడులు వారికి కంటే పెద్ద ఉంటే.

901
01:02:55,000 --> 01:02:58,000
అప్పుడు రెండవ మరియు మూడవ అదే పని, మార్పిడులు, పోల్చి

902
01:02:58,000 --> 01:03:00,000
మూడవ మరియు నాల్గవ, అన్ని మార్గం డౌన్.

903
01:03:00,000 --> 01:03:03,000
పెద్ద సంఖ్యలో చివర సంప్రదిస్తుంది.

904
01:03:03,000 --> 01:03:07,000
అయితే అనేక లూప్ల తర్వాత మీరు పూర్తి చేసిన.

905
01:03:07,000 --> 01:03:11,000
సరిగ్గా, సో వాట్ కెవిన్ చెప్పాడు మేము పెద్ద సంఖ్యలో చూస్తాను ఉంది

906
01:03:11,000 --> 01:03:15,000
అర్రే చివర బబుల్ అప్.

907
01:03:15,000 --> 01:03:19,000
ఈ మా శ్రేణి ఉదాహరణకు, మీరు ఈ ఉదాహరణ ద్వారా మాకు వాకింగ్ పట్టించుకోవడం లేదు?

908
01:03:19,000 --> 01:03:21,000
[కెవిన్] మీరు 2 తీసుకొని 3 చేస్తాము.

909
01:03:21,000 --> 01:03:23,000
3 2 కన్నా పెద్దది, కాబట్టి మీరు వాటిని మార్పిడి.

910
01:03:23,000 --> 01:03:29,000
[నేట్ H.] కుడి, కాబట్టి మేము ఈ మార్పిడి, అందువలన మేము, 3, 4 6 2 పొందండి, మరియు 9.

911
01:03:29,000 --> 01:03:31,000
[కెవిన్] అప్పుడు మీరు 3 మరియు 6 పోల్చండి.

912
01:03:31,000 --> 01:03:33,000
, 3 6 కంటే తక్కువగా ఉంటుంది, అందువలన మీరు వాటిని వదిలి

913
01:03:33,000 --> 01:03:37,000
4 6 కంటే తక్కువగా ఉంటుంది ఎందుకంటే మరియు 6 మరియు 4, మీరు వాటిని మార్పిడి భావిస్తున్న.

914
01:03:37,000 --> 01:03:42,000
[నేట్ H.] కుడి, నేను 2, 3, 4, 6, 9 పొందండి.

915
01:03:42,000 --> 01:03:46,000
[కెవిన్] మరియు 9 6 కన్నా పెద్దది, కాబట్టి మీరు వదిలి.

916
01:03:46,000 --> 01:03:48,000
మరియు మీరు మళ్ళీ దాన్ని ద్వారా తిరిగి వెళ్ళాలి.

917
01:03:48,000 --> 01:03:50,000
>> నేను ఈ సమయంలో [నేట్ H.] పూర్తి వున్నాను? >> [కెవిన్] నం

918
01:03:50,000 --> 01:03:52,000
మరియు నేను ఈ సమయంలో పూర్తి లేదు?

919
01:03:52,000 --> 01:03:54,000
నా శ్రేణి క్రమబద్ధీకరించబడింది కనిపిస్తుంది ఎందుకంటే. నేను వద్ద చూస్తున్నాను.

920
01:03:54,000 --> 01:03:57,000
[కెవిన్] మళ్లీ ఇది ద్వారా వెళ్లి no more మార్పిడులు ఉన్నాయి నిర్ధారించుకోండి

921
01:03:57,000 --> 01:04:00,000
మీరు పూర్తిగా మానివేయవచ్చు ముందు.

922
01:04:00,000 --> 01:04:04,000
సరిగ్గా, కాబట్టి మీరు ద్వారా కొనసాగించడాన్ని మరియు మార్పిడులు ఉన్నాయి నిర్ధారించుకోవాలనుకుంటున్నాము

923
01:04:04,000 --> 01:04:06,000
మీరు ఈ సమయంలో చేసే.

924
01:04:06,000 --> 01:04:08,000
మీరు చెప్పినట్టూ మనం అప్ ముగిసింది, నిజంగా కేవలం అదృష్టవశాత్తు

925
01:04:08,000 --> 01:04:12,000
మాత్రమే ద్వారా 1 తరలింపు అవసరం మరియు మేము క్రమబద్ధీకరించబడతాయి చేస్తున్నారు.

926
01:04:12,000 --> 01:04:16,000
కానీ సాధారణ సందర్భంలో దీన్ని మేము నిజంగా మళ్ళీ మరియు ఈ విధంగా ఉంటుంది.

927
01:04:16,000 --> 01:04:20,000
నిజానికి, ఈ, ఉత్తమ కేసులో ఒక ఉదాహరణ

928
01:04:20,000 --> 01:04:24,000
వంటి మేము సమస్య చూసిన.

929
01:04:24,000 --> 01:04:28,000
మేము ఉత్తమ కేసు n గమనించాను.

930
01:04:28,000 --> 01:04:32,000
మేము అర్రే 1 సమయం సాగింది.

931
01:04:32,000 --> 01:04:35,000
ఈ అల్గోరిథం కోసం చెత్త పాజిబుల్ కేస్ ఏమిటి?

932
01:04:35,000 --> 01:04:37,000
[కెవిన్] N ².

933
01:04:37,000 --> 01:04:41,000
మరియు ఆ చూడవచ్చు ఇష్టం లేదు? ఏ వ్యూహం అనిపించే వంటి n ² సమయం తీసుకుంటుంది చేస్తుంది?

934
01:04:41,000 --> 01:04:43,000
[కెవిన్] [వినబడని] క్రమబద్ధీకరించబడతాయి.

935
01:04:43,000 --> 01:04:51,000
నేను శ్రేణి 9, 7, 6, 5, 2, కలిగి ఖచ్చితంగా అయితే

936
01:04:51,000 --> 01:04:54,000
మొదటి 9 అప్ బబుల్ అన్ని మార్గం చేస్తాను.

937
01:04:54,000 --> 01:04:59,000
1 మళ్ళా తర్వాత మేము 7, 6, 5, 2, 9 భావిస్తాను.

938
01:04:59,000 --> 01:05:07,000
అప్పుడు, 7 అప్ బుడగ, 6, 5, 2, 7, 9, అందువలన న మొదలగునవి చేస్తాను.

939
01:05:07,000 --> 01:05:13,000
>> మేము, మొత్త n సార్లు ద్వారా వెళ్ళడానికి భావిస్తాను

940
01:05:13,000 --> 01:05:16,000
మరియు మీరు నిజంగా ఈ కంటే ఎక్కువ ఖచ్చితమైన పొందవచ్చు

941
01:05:16,000 --> 01:05:23,000
ఒకసారి మేము దాని చివరి స్థానం విభజించవచ్చు 9 అన్ని మార్గం తరలించారు ఎందుకంటే

942
01:05:23,000 --> 01:05:26,000
మేము మళ్లీ ఆ మూలకం వ్యతిరేకంగా పోల్చడానికి లేదు తెలుసు.

943
01:05:26,000 --> 01:05:29,000
ఒకసారి మేము 7 ప్రసారమయ్యే ప్రారంభం

944
01:05:29,000 --> 01:05:35,000
మేము 7 కుడి 9 ముందు ఒకసారి మేము ఆపడానికి మీకు

945
01:05:35,000 --> 01:05:37,000
మేము ఇప్పటికే అది 9 పోలిస్తే చేసిన నుండి.

946
01:05:37,000 --> 01:05:46,000
మీరు స్మార్ట్ విధంగా ఇలా చేస్తే అది, నేను ఊహిస్తున్నాను, నిజంగా చాలా సమయం కాదు.

947
01:05:46,000 --> 01:05:49,000
మీరు ఉన్న అన్ని [వినబడని] కాంబినేషన్ పోల్చడానికి వెళ్ళి లేదు

948
01:05:49,000 --> 01:05:55,000
ప్రతి మీరు ప్రతి పునరావృతం ద్వారా వెళ్లండి.

949
01:05:55,000 --> 01:05:59,000
కానీ, మేము ఈ ఉన్నత బౌండ్ గురించి మాట్లాడేందుకు మేము పేర్కొన్నట్లు

950
01:05:59,000 --> 01:06:04,000
మీరు n చూస్తున్నారు ² పోలికలు అన్ని చెప్పారు.

951
01:06:04,000 --> 01:06:12,000
>> మేము సమయం కొద్దిగా చిన్న పొందడానికి మొదలు పెడుతున్నారు నుండి యొక్క తిరిగి వెళ్ళి తెలపండి, మరియు

952
01:06:12,000 --> 01:06:15,000
నేను, మీరు ఖచ్చితంగా ఈ పట్టిక యొక్క మిగిలిన వెళ్ళాలి చెబుతా

953
01:06:15,000 --> 01:06:17,000
అన్ని పూరించండి.

954
01:06:17,000 --> 01:06:20,000
ఉదాహరణలు గురించి ఆలోచించండి. కాంక్రీటు ఉదాహరణలు గురించి ఆలోచించండి.

955
01:06:20,000 --> 01:06:22,000
అలా ఎంతో సులభ మరియు ఉపయోగపడిందా ఉంది.

956
01:06:22,000 --> 01:06:25,000
అది తీసుకోవటం.

957
01:06:25,000 --> 01:06:28,000
ఈ పట్టిక యొక్క విధమైన అని మీరు కంప్యూటర్ సైన్స్ లో ద్వారా వెళ్ళి వంటి

958
01:06:28,000 --> 01:06:32,000
మీరు నిజంగా ఈ ద్వారా గుండె తెలుసుకోవటానికి ప్రారంభం కావాలి.

959
01:06:32,000 --> 01:06:34,000
ఈ మీరు ఇన్ ఇంటర్వ్యూ పొందండి వివిధ రకాల ప్రశ్నలను ఉంటాయి.

960
01:06:34,000 --> 01:06:36,000
ఈ తెలుసుకోవాలనుకుంటున్నారు, మంచి పనులు ఎటువంటి ఉంటాయి

961
01:06:36,000 --> 01:06:41,000
మరియు నిజంగా గురించి ఆలోచించటం ఎలా ఇందుకు, ఆ అంచు సందర్భాలలో గురించి ఆలోచించటం

962
01:06:41,000 --> 01:06:45,000
బుడగ కోసం చెత్త సాధ్యం శ్రేణి క్రమం తెలుసుకునేందుకు

963
01:06:45,000 --> 01:06:52,000
ఆ క్రమం వ్యతిరేక క్రమంలో ఉండే ఒకటి.

964
01:06:52,000 --> 01:06:58,000
>> పాయింటర్లు. యొక్క గమనికలు గురించి కొద్దిగా చర్చ లెట్.

965
01:06:58,000 --> 01:07:03,000
గత కొద్ది నిమిషాల్లో మేము ఇక్కడ ఉన్నాయి

966
01:07:03,000 --> 01:07:11,000
నేను ఈ I / O ఆ కాకుండా కొత్త ఉంది ఫైలు పాటు విషయం తెలుసు.

967
01:07:11,000 --> 01:07:19,000
మేము గమనికలు గురించి మేము గమనికలు గురించి మాట్లాడు కారణం మాట్లాడేటప్పుడు

968
01:07:19,000 --> 01:07:24,000
మేము సి లో పనిచేసే ఒక, ఎందుకంటే

969
01:07:24,000 --> 01:07:33,000
మేము చాలా ఆధునిక ప్రోగ్రామింగ్ భాషలు పోలిస్తే చాలా తక్కువ స్థాయిలో అయి ఉన్నారు.

970
01:07:33,000 --> 01:07:38,000
మేము, వాస్తవానికి మెమరీలో వేరియబుల్స్ సవరించడానికి చూడగలరని

971
01:07:38,000 --> 01:07:43,000
వారు వాస్తవానికి మా RAM లోపల ఎక్కడ ఉన్నారు గుర్తించడానికి.

972
01:07:43,000 --> 01:07:46,000
ఒకసారి మీరు చూస్తారు ఆపరేటింగ్ సిస్టమ్ తరగతులను తీసుకోవటానికి న మారారు

973
01:07:46,000 --> 01:07:48,000
ఆ, మళ్ళీ, ఒక ఊహ యొక్క ఉంటాము.

974
01:07:48,000 --> 01:07:50,000
వాస్తవానికి కేసు కాదు.

975
01:07:50,000 --> 01:07:52,000
మేము మా నుండి ఆ వివరాలు దాచి చేసే కాల్పనిక స్మృతి పొందారు.

976
01:07:52,000 --> 01:07:58,000
>> మీరు ఒక ప్రోగ్రామ్ను కానీ ఇప్పుడు కోసం మీరు, ఆ పొందవచ్చు

977
01:07:58,000 --> 01:08:02,000
ఉదాహరణకు, మీరు ప్రారంభించడానికి మీ సీజర్ సాంకేతికలిపి కార్యక్రమ అమలు

978
01:08:02,000 --> 01:08:06,000
నేను నిజంగా వేగంగా నా ఐప్యాడ్ తిరిగి మారవచ్చు చేస్తాము

979
01:08:06,000 --> 01:08:12,000
మీరు కలిగి ఉంటే వారు ప్రారంభం మీ కార్యక్రమం, పేర్కొన్నట్లు

980
01:08:12,000 --> 01:08:15,000
మీ ల్యాప్టాప్ న RAM యొక్క 4 గిగాబైట్లు,

981
01:08:15,000 --> 01:08:21,000
మీరు ఈ భాగం పక్కన పెట్టింది అందుకోవటం, మరియు మేము ఈ RAM పిలుస్తాను.

982
01:08:21,000 --> 01:08:25,000
మరియు అది, మేము 0 కాల్ చూడాలని ఒక స్థానంలో మొదలవుతుంది

983
01:08:25,000 --> 01:08:30,000
మరియు అది మేము 4 గిగాబైట్లు పిలుస్తాను ఒక ప్రదేశంలో ముగుస్తుంది.

984
01:08:30,000 --> 01:08:37,000
నేను నిజంగా రాయలేదు. మాన్, ఆ హ్యాక్ ఉంది.

985
01:08:37,000 --> 01:08:40,000
మీ ప్రోగ్రామ్ అమలు చేసినప్పుడు

986
01:08:40,000 --> 01:08:44,000
ఆపరేటింగ్ సిస్టమ్, RAM అప్ వంపులు తిరుగుతున్న

987
01:08:44,000 --> 01:08:51,000
మరియు అది నివసించే మీ ప్రోగ్రామ్ యొక్క వివిధ భాగాల కోసం వివిధ భాగాల్లో నిర్దేశిస్తుంది

988
01:08:51,000 --> 01:08:58,000
ఇక్కడ డౌన్ ఈ ప్రాంతంలో ఒక నో మ్యాన్స్ ల్యాండ్ యొక్క రకం.

989
01:08:58,000 --> 01:09:02,000
మీరు దూరంగా ఇక్కడ కొద్దిగా పైకి వెళ్ళగానే

990
01:09:02,000 --> 01:09:05,000
మీరు నిజంగా స్థలం పొందారు పేరు

991
01:09:05,000 --> 01:09:09,000
మీ ప్రోగ్రామ్ ప్రాణాలను కోడ్.

992
01:09:09,000 --> 01:09:13,000
ఆ వాస్తవ బైనరీ కోడ్, ఆ ఎక్జిక్యూటబుల్ ఫైల్ నిజానికి మెమరీ లోనికి లోడ్ అవుతుంది

993
01:09:13,000 --> 01:09:17,000
మీరు ఒక ప్రోగ్రామ్ రన్, మరియు అది కోడ్ విభాగంలో నివసిస్తున్నారు ఉన్నప్పుడు.

994
01:09:17,000 --> 01:09:22,000
మీ ప్రోగ్రామ్ అమలు మరియు ప్రాసెసర్ ఈ కోడ్ విభాగంలో వద్ద ఉంది

995
01:09:22,000 --> 01:09:24,000
గుర్తించడానికి మరో ఆదేశం ఏమిటి?

996
01:09:24,000 --> 01:09:27,000
నేను అమలు చేయాలి కోడ్ తదుపరి లైన్ ఏమిటి?

997
01:09:27,000 --> 01:09:31,000
>> అక్కడ ఒక డేటా విభాగంలో కూడా, మరియు ఈ పేరు ఆ స్ట్రింగ్ స్థిరాంకాలు ఉంది

998
01:09:31,000 --> 01:09:34,000
మీరు ఉపయోగించి చేసిన ఆ నిల్వ చేయబడ్డాయి.

999
01:09:34,000 --> 01:09:42,000
ఆపై దూరంగా అప్ కుప్ప అని ఈ ప్రాంతం మరొకటి లేదు.

1000
01:09:42,000 --> 01:09:46,000
మేము, malloc ఉపయోగించి అక్కడ మెమొరీ యాక్సెస్

1001
01:09:46,000 --> 01:09:49,000
ఆపై మీ ప్రోగ్రామ్ యొక్క చాలా భాగంలో

1002
01:09:49,000 --> 01:09:52,000
స్టాక్ లేదు

1003
01:09:52,000 --> 01:09:57,000
మేము ప్రారంభం చాలా ప్లే ఎక్కడ ఉన్నాను మరియు ఆ.

1004
01:09:57,000 --> 01:09:59,000
ఈ తరహా లేదా ఏదైనా కాదు.

1005
01:09:59,000 --> 01:10:03,000
ఈ చాలా, చాలా యంత్రం ఆధారపడి ఉంటుంది

1006
01:10:03,000 --> 01:10:10,000
వ్యవస్థ ఆధారపడి ఆపరేటింగ్, కానీ ఈ విషయాలు అప్ chunked get సాపేక్షంగా ఎలా ఉంది.

1007
01:10:10,000 --> 01:10:17,000
మీరు ఒక ప్రోగ్రామ్ రన్ మరియు మీరు అని x-ఒక వేరియబుల్ డిక్లేర్ చేసినప్పుడు

1008
01:10:17,000 --> 01:10:27,000
నేను క్రింద దిగువ మరొక పెట్టెను గీయండి వెళుతున్న మరియు ఈ అదే RAM అని అన్నారు.

1009
01:10:27,000 --> 01:10:29,000
నేను చూడండి వెళుతున్న.

1010
01:10:29,000 --> 01:10:34,000
మేము ఈ కేవలం RAM యొక్క ఒక చిన్న విభాగం సూచించడానికి కత్తిరించిన పంక్తులు డ్రా చేస్తాము

1011
01:10:34,000 --> 01:10:38,000
మరియు అది అన్ని మేము ఎగువన డ్రా కాదు.

1012
01:10:38,000 --> 01:10:43,000
>> నేను x అనే ఒక పూర్ణాంకం వేరియబుల్, డిక్లేర్ ఉంటే

1013
01:10:43,000 --> 01:10:49,000
అప్పుడు నేను నిజంగా పొందండి మాపింగ్ ఉంది

1014
01:10:49,000 --> 01:10:54,000
నా ప్రోగ్రామ్ యొక్క చిహ్నం పట్టిక నిల్వ చేయబడిన

1015
01:10:54,000 --> 01:11:00,000
ఆ నేను డ్రా చేసిన మెమరీ ఈ ప్రాంతానికి పేరు x కలుపుతుంది

1016
01:11:00,000 --> 01:11:03,000
ఇక్కడే నిలువు బార్లు మధ్య.

1017
01:11:03,000 --> 01:11:08,000
నేను x = 7 అని నా కార్యక్రమంలో కోడ్ ఒక లైన్ ఉంటే

1018
01:11:08,000 --> 01:11:15,000
ప్రాసెసర్ తెలుసు "ఓహ్, ఓకే, నేను తెలిసిన మెమరీలో ఈ స్థానంలో x జీవితాలను."

1019
01:11:15,000 --> 01:11:25,000
"నేను ముందుకు వెళ్లి అక్కడ ఒక 7 రాయడానికి వెళుతున్న."

1020
01:11:25,000 --> 01:11:28,000
ఎలా ఈ మెమరీ ఉంది ఏమి నగర తెలుసా?

1021
01:11:28,000 --> 01:11:30,000
Well, అన్ని కంపైల్ సమయంలో పూర్తి చేసిన.

1022
01:11:30,000 --> 01:11:34,000
వేరియబుల్స్ యొక్క ప్రతి వెళ్ళి వెళ్ళి ఇక్కడ కంపైలర్ పెడుతోంది జాగ్రత్త తీసుకుంటుంది

1023
01:11:34,000 --> 01:11:40,000
మరియు ఒక ప్రత్యేక మ్యాపింగ్ సృష్టించడానికి బదులుగా చుక్కలు కనెక్ట్

1024
01:11:40,000 --> 01:11:43,000
చిహ్నంగా మరియు అది జరగబోతోంది పేరు, ఒక వేరియబుల్ పేరు మధ్య

1025
01:11:43,000 --> 01:11:46,000
మరియు మెమరీ నివసించడానికి జరగబోతోంది పేరు.

1026
01:11:46,000 --> 01:11:50,000
కానీ మేము నిజంగా అదే మా కార్యక్రమాలలో దీనిని ఆక్సెస్ చేసుకోవచ్చు అవుతుంది.

1027
01:11:50,000 --> 01:11:55,000
మేము డేటా నిర్మాణాలు కొన్ని గురించి మాట్లాడుతూ ప్రారంభించిన ఈ, ముఖ్యమైన గెట్స్

1028
01:11:55,000 --> 01:11:58,000
ఇది మేము తర్వాత పరిచయం చూడాలని ఉద్దేశ్యంతో ఒక భావన.

1029
01:11:58,000 --> 01:12:09,000
>> కానీ ఇప్పుడు కోసం, ఏ మీకు చేయవచ్చు నేను, ఈ స్థానానికి x ఒక పాయింటర్ సృష్టించడానికి ఉంది.

1030
01:12:09,000 --> 01:12:12,000
ఉదాహరణకు, నేను ఒక పాయింటర్ వేరియబుల్ సృష్టించవచ్చు.

1031
01:12:12,000 --> 01:12:16,000
మేము ఒక పాయింటర్ వేరియబుల్ రూపొందించినప్పుడు మేము స్టార్ నోటేషన్ ను ఉపయోగిస్తాయి.

1032
01:12:16,000 --> 01:12:21,000
ఈ సందర్భంలో, ఈ నేను ఒక పూర్ణాంకానికి ఒక పాయింటర్ సృష్టించడానికి వెళుతున్న చెప్పారు.

1033
01:12:21,000 --> 01:12:24,000
ఇది ఏదైనా ఇతర వంటి ఒక రకం.

1034
01:12:24,000 --> 01:12:27,000
మేము, అది y వంటి వేరియబుల్ ఇవ్వాలని

1035
01:12:27,000 --> 01:12:32,000
మరియు తర్వాత మేము ఒక చిరునామాకు, చిరునామా దానిని సమానంగా సెట్.

1036
01:12:32,000 --> 01:12:38,000
ఈ సందర్భంలో, మనం x సూచించడానికి Y సెట్ చేయవచ్చు

1037
01:12:38,000 --> 01:12:43,000
ఈ ఆంపర్సండ్ చిహ్నం తో మేము ఇవి x యొక్క చిరునామా, తీసుకొని,

1038
01:12:43,000 --> 01:12:55,000
మరియు తర్వాత మేము అది సూచించడానికి Y సెట్.

1039
01:12:55,000 --> 01:12:59,000
మేము మా RAM వద్ద చూస్తే ఇది తప్పనిసరిగా ఏమిటి లేదు

1040
01:12:59,000 --> 01:13:02,000
ఈ ప్రత్యేక వేరియబుల్ సృష్టిస్తుంది.

1041
01:13:02,000 --> 01:13:04,000
ఇది y కాల్ వెళుతున్న

1042
01:13:04,000 --> 01:13:06,000
మరియు కోడ్ ఈ రేఖను అమలు చేసినప్పుడు

1043
01:13:06,000 --> 01:13:13,000
నిజానికి, మేము సాధారణంగా ఒక బాణం వంటి డ్రా ఇది కొద్దిగా పాయింటర్ సృష్టించడానికి జరగబోతోంది

1044
01:13:13,000 --> 01:13:15,000
మరియు అది x సూచించడానికి Y అమర్చుతుంది.

1045
01:13:15,000 --> 01:13:17,000
అవును.

1046
01:13:17,000 --> 01:13:19,000
X ఇప్పటికే పాయింటర్ ఉంటే [స్టూడెంట్], మీరు అని

1047
01:13:19,000 --> 01:13:22,000
Int * Y = x బదులుగా ఆంపర్సండ్ చిహ్నం కలిగి?

1048
01:13:22,000 --> 01:13:24,000
అవును.

1049
01:13:24,000 --> 01:13:27,000
X ఇప్పటికే పాయింటర్ ఉంటే, అప్పుడు మీరు, ప్రతి ఇతర సమానంగా 2 గమనికలు సెట్ చేయవచ్చు

1050
01:13:27,000 --> 01:13:30,000
ఈ సందర్భంలో y, x సూచించడానికి కాదు

1051
01:13:30,000 --> 01:13:34,000
కానీ కు సూచిస్తుంది ఏ x సూచించడానికి చేస్తుంది.

1052
01:13:34,000 --> 01:13:37,000
దురదృష్టవశాత్తు, మేము సమయం లేదు.

1053
01:13:37,000 --> 01:13:44,000
>> నేను ఈ సమయంలో చెబుతారు వాట్ మేము, ఈ ఆఫ్లైన్ గురించి మాట్లాడవచ్చు

1054
01:13:44,000 --> 01:13:49,000
కానీ నేను, ఈ సమస్య ద్వారా # 14 పని మొదలు చెబుతారు.

1055
01:13:49,000 --> 01:13:53,000
మీరు పూరించిన కొద్దిగా ఇక్కడ ఇప్పటికే ఉంది చూడగలరు.

1056
01:13:53,000 --> 01:13:57,000
మేము 2 గమనికలు డిక్లేర్ మీరు ఆ చూడగలరు, Int * x మరియు * Y,

1057
01:13:57,000 --> 01:14:01,000
మరియు వేరియబుల్ పక్కన * పై గమనించండి గత ఏడాది జరిగింది ఏదో జరిగింది.

1058
01:14:01,000 --> 01:14:05,000
ఈ మేము ఈ సంవత్సరం చేయడం ఏమి ఉండే అవుతుంది.

1059
01:14:05,000 --> 01:14:11,000
మీరు పాయింటర్ ప్రకటించారు చేసినప్పుడు మీరు * వ్రాయడానికి పేరు ఇది పట్టింపు లేదు.

1060
01:14:11,000 --> 01:14:17,000
కానీ మేము రకం పక్కన * వ్రాశారు

1061
01:14:17,000 --> 01:14:24,000
ఇది చాలా స్పష్టంగా మీరు ఒక పాయింటర్ వేరియబుల్ ప్రకటించారు చేస్తున్న చేస్తుంది ఎందుకంటే.

1062
01:14:24,000 --> 01:14:27,000
మీరు 2 గమనికలు ప్రకటించారు మాకు 2 బాక్సులను ఇచ్చే చూడగలరు.

1063
01:14:27,000 --> 01:14:31,000
ఇక్కడ మేము malloc సమానంగా x పెట్టినప్పుడు

1064
01:14:31,000 --> 01:14:34,000
ఈ చెబుతున్నారు కుప్ప లో మెమొరీ పక్కన సెట్ చేస్తుంది.

1065
01:14:34,000 --> 01:14:41,000
ఇక్కడే ఈ చిన్న పెట్టెలో, ఈ సర్కిల్, కుప్ప ఉంది.

1066
01:14:41,000 --> 01:14:43,000
X అది కు సూచిస్తుంది.

1067
01:14:43,000 --> 01:14:46,000
Y ఇప్పటికీ ఏదైనా సూచించే గమనించండి.

1068
01:14:46,000 --> 01:14:50,000
పొందడానికి మెమరీ నుంచి x లోకి సంఖ్య 42 నిల్వ

1069
01:14:50,000 --> 01:14:55,000
మేము ఏ సంజ్ఞామానం ఉపయోగించే?

1070
01:14:55,000 --> 01:14:59,000
[స్టూడెంట్] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
సరిగ్గా, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
ఆ బాణం అనుసరించండి మరియు 42 త్రో అర్థం.

1073
01:15:06,000 --> 01:15:09,000
ఇక్కడ మేము Y మరియు x సెట్ పేరు మేము Y x సూచించే చేశారు.

1074
01:15:09,000 --> 01:15:13,000
మళ్ళీ, ఈ కేవలం మేము x కు y సమానమైన సెట్ పేరు కెవిన్ మాట్లాడుతూ చెప్పారు.

1075
01:15:13,000 --> 01:15:15,000
Y x సూచించే లేదు.

1076
01:15:15,000 --> 01:15:19,000
అయితే, x అలాగే కు సూచిస్తుంది ఏమి సూచించే యొక్క.

1077
01:15:19,000 --> 01:15:24,000
>> మరియు తర్వాత చివరకు ఈ చివరి బాక్స్ లో మేము చేయగల 2 సాధ్యం విషయాలు ఉన్నాయి.

1078
01:15:24,000 --> 01:15:28,000
ఒక మేము * x = 13 చెప్పగల్గినవి ఉంది.

1079
01:15:28,000 --> 01:15:33,000
ఇతర విషయం మేము సే-అలెక్స్, మీరు మేము ఇక్కడ ఏమి చేయగలరో తెలుసు కాలేదు ఉంది?

1080
01:15:33,000 --> 01:15:37,000
మీరు చెప్పగల్గినవి * x = 13 లేదా

1081
01:15:37,000 --> 01:15:41,000
[స్టూడెంట్] మీరు Int ఏ చెప్పొచ్చు.

1082
01:15:41,000 --> 01:15:45,000
[నేట్ H.] ఈ ఒక పూర్ణాంకానికి వేరియబుల్ గా సూచించబడ్డాయి ఉంటే మేము ఆ పని చేయడు.

1083
01:15:45,000 --> 01:15:49,000
మేము కూడా * Y = 13 ఇద్దరూ ఒకే చోట సూచించే ఉన్నందున, చెప్పగల్గినవి

1084
01:15:49,000 --> 01:15:51,000
కాబట్టి మేము అక్కడ పొందడానికి గాని వేరియబుల్ ఉపయోగించవచ్చు.

1085
01:15:51,000 --> 01:15:56,000
అవును. >> [స్టూడెంట్] మేము Int x 13 చెప్తున్నారు ఉంటే ఇష్టం అది చూస్తారు?

1086
01:15:56,000 --> 01:16:00,000
ఆ పని చేసే x అనే ఒక కొత్త కారకం ప్రకటించే ఉంటుంది.

1087
01:16:00,000 --> 01:16:04,000
మేము x ఇక్కడ ఒక పాయింటర్ అప్ ప్రకటించింది ఎందుకంటే మేము ఢీకొట్టడంతో భావిస్తాను.

1088
01:16:04,000 --> 01:16:10,000
[స్టూడెంట్] మేము స్వయంగా ఆ ప్రకటన కలిగి ఉంటే అది సర్కిల్ పరంగా ఇష్టం చూస్తారు?

1089
01:16:10,000 --> 01:16:14,000
మేము x కలిగి ఉంటే = 13 అప్పుడు మేము ఒక బాక్స్, మరియు బదులుగా ఒక బాణం కలిగి కంటే కావలసిన

1090
01:16:14,000 --> 01:16:16,000
బాక్స్ యొక్క రావడం మేము కేవలం 13 గా డ్రా భావిస్తున్న.

1091
01:16:16,000 --> 01:16:19,000
బాక్స్లో [స్టూడెంట్]. సరే.

1092
01:16:19,000 --> 01:16:24,000
>> చూడటం ధన్యవాదాలు, మరియు క్విజ్ 0 లో అదృష్టం.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]