1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [రివ్యూ] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi రాస్, టామీ MacWilliam, లుకాస్ ఫ్రీటస్, జోసెఫ్ వోంగ్] [హార్వర్డ్ విశ్వవిద్యాలయం]

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 ఇతర TFS తో ఉన్నాను

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
>> [లాజిస్టిక్స్] [Quiz ఉపన్యాసం బదులుగా బుధవారం 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-అక్కడ 's నుండి ప్రాప్తి అది-

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
మీ TFS, కొన్ని ఆచరణ సమస్యలు మీద వెళ్ళడం చేయాలి

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
కలిసి ఆ D. చేస్తుంది, 13 చేస్తాడు

43
00:02:28,000 --> 00:02:32,000
మరియు మేము హెక్సాడెసిమల్ లో మేము 9 ద్వారా 0 జరగనప్పుడు గుర్తుంచుకోవాలి చేస్తాము.

44
00:02:32,000 --> 00:02:36,000
మేము 9 తర్వాత, F ద్వారా కి 10 సమంగా 0 వెళ్ళి,

45
00:02:36,000 --> 00:02:40,000
F 15 ఉన్న 11 బి, et సెటేరా.

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, సున్నా 8, ఒక 16, et సెటేరా, యొక్క

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
కొనసాగిస్తూ, ఈ, ఒక ASCII టేబుల్ ఉంది

57
00:03:29,000 --> 00:03:35,000
మరియు మేము కోసం ASCII ఉపయోగం అక్షరాలు నుండి సంఖ్యా విలువలకు ను ఉంటుంది.

58
00:03:35,000 --> 00:03:39,000
గూఢ లిపి శాస్త్రం pset లో గుర్తుంచుకో మేము ASCII టేబుల్ విస్తృతంగా వాడారు

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
Q అని పాత్ర రూపంలో, 'P' వద్ద + 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
మరియు ఆ విధంగా ASCII పట్టికలో ఒక విలువ సూచించదు.

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
>> ఒక In లూప్ మేము సాధారణంగా ఇప్పటికే మేము iterate మీరు ఎలా అనేక సార్లు తెలుసు.

116
00:07:21,000 --> 00:07:24,000
అంటే పరిస్థితిలో ఉంచారు ఏమిటి.

117
00:07:24,000 --> 00:07:28,000
నేను = 0, i <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
ప్రారంభ, సాధారణంగా ఏదో వంటి Int నేను కౌంటర్ ఉన్న = 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
మేము Int i = 0 లూప్ ముందే చెబుతారు.

151
00:09:16,000 --> 00:09:20,000
I <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 బార్, వేరియబుల్ బార్ initializes

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
ఇప్పుడు, కోర్సు యొక్క, మేము ఈ ఒక పంక్తిలో, Int బార్ = 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
ఇది తదుపరి, Int బాజ్ = బార్ + 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
మేము ప్రధానంగా, స్క్రాచ్ ఈ చేశాడు

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
కానీ విధమైన బొత్తిగా మేము ఆ విధంగా అది కూడా ఆలోచించవచ్చు.

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
నేను అందుకున్నప్పుడు మరియు, నేను వినిపించడం లేదు చేసినప్పుడు, వాస్తవానికి ఉంది

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
యొక్క ఈ సులభమైన సి కార్యక్రమం చూద్దాం.

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
మేము ప్రధాన పై Int చూడండి. తిరిగి టైప్ అదే, అందువలన క్రింద 0 తిరిగి.

209
00:12:38,000 --> 00:12:41,000
మరియు మేము Int పొందండి CS50 లైబ్రరీ ఫంక్షన్ ఉపయోగించే

210
00:12:41,000 --> 00:12:45,000
ఇన్పుట్ కోసం వినియోగదారు అడగండి మరియు మేము ఈ చరరాశి 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
ఓహ్, Int 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
హేయ్, guys. నా పేరు లుకాస్ ఉంది.

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!] [లుకాస్ ఫ్రీటస్]

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
మీరు C లో ఒక ప్రోగ్రామ్ రాస్తున్నాం కాబట్టి ఉన్నప్పుడు

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 సె మరియు 1s అర్ధం చేసుకోగలరు

247
00:14:57,000 --> 00:15:01,000
కాబట్టి నిజంగా మొదటి కంప్యూటర్లలో ప్రజలు సాధారణంగా ప్రోగ్రామ్

248
00:15:01,000 --> 00:15:04,000
ఇకపై 0 సె మరియు 1s, కానీ ఉపయోగించి, దేవుని ధన్యవాదాలు.

249
00:15:04,000 --> 00:15:07,000
మేము 0 సె మరియు 1s కోసం సన్నివేశాలు గుర్తు లేదు

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-bit మిషన్, కోసం ఉన్నాయి

293
00:17:53,000 --> 00:17:56,000
కానీ మీరు నిజంగా మీ Mac లేదా Windows లో కూడా కోడింగ్ ఉంటే

294
00:17:56,000 --> 00:17:59,000
బహుశా మీరు ఒక 64-bit మిషన్ చూడాలని

295
00:17:59,000 --> 00:18:03,000
నేను వెళుతున్నాను అని డేటా పరిమాణాలు ఇక్కడ చూపడానికి గుర్తుంచుకోవాలి

296
00:18:03,000 --> 00:18:06,000
32-bit మిషన్ కోసం ఉన్నాయి.

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
మీరు ఒక పూర్ణాంకం నిల్వ Int ఉపయోగించండి.

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 కలిగి ఒక ASCII పట్టికను కలిగి

304
00:18:31,000 --> 00:18:34,000
0 సె మరియు 1s యొక్క సాధ్యమైన కలయికల,

305
00:18:34,000 --> 00:18:37,000
మరియు తర్వాత మీరు ఒక చార్ టైప్ చేసినప్పుడు అది అనువదించడానికి జరగబోతోంది

306
00:18:37,000 --> 00:18:44,000
పాత్ర ఇన్పుట్లను మీరు Lexi వంటి ASCII పట్టిక కలిగి అనేక చెప్పారు.

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
లేదా మరింత PRECISION కలిగి డబుల్.

310
00:18:55,000 --> 00:18:57,000
ఫ్లోట్ 4 బైట్లు ఉంది.

311
00:18:57,000 --> 00:19:01,000
ఒక డబుల్ 8 బైట్లు ఉన్నాయి, కాబట్టి మాత్రమే తేడా PRECISION ఉంది.

312
00:19:01,000 --> 00:19:04,000
మేము కూడా, పూర్ణ సంఖ్యలు ఉపయోగించే కలిగి

313
00:19:04,000 --> 00:19:09,000
మరియు మీరు, ఒక Int మరియు దీర్ఘ అదే పరిమాణం కలిగి 32-bit మిషన్ కోసం చూడగలరు

314
00:19:09,000 --> 00:19:13,000
కనుక దీనిని ఒక వాస్తవిక 32-bit మిషన్ లో సుదీర్ఘ ఉపయోగించడానికి సమంజసం అనిపించుకోదు.

315
00:19:13,000 --> 00:19:17,000
>> మీరు ఒక Mac మరియు 64-bit మిషన్ ఉపయోగించే అయితే, వాస్తవానికి సుదీర్ఘ, పరిమాణం 8 ఉంది

316
00:19:17,000 --> 00:19:19,000
కాబట్టి ఇది నిజంగా నిర్మాణం మీద ఆధారపడి ఉంటుంది.

317
00:19:19,000 --> 00:19:22,000
32-bit మిషన్ ఇది నిజంగా ఒక పెద్ద ఉపయోగించడానికి సమంజసం అనిపించుకోదు.

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
మేము కూడా, CASTING గురించి కొద్దిగా నేర్చుకున్నాను

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, అవును.

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
A, మీరు ఇక్కడ అలా ప్రధానంగా ఏమి

361
00:21:59,000 --> 00:22:02,000
, పాత్ర లోకి పూర్ణాంక అనువాదం ఉంది

362
00:22:02,000 --> 00:22:05,000
కేవలం వంటి ASCII టేబుల్ చేస్తుంది.

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 సంఖ్యలను విభజన మిగిలిన ఇది mod, మాట్లాడారు.

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
విజెనెరే మరియు సీజర్ నేను మీరు అబ్బాయిలు అన్ని mod ఉపయోగించిన చాలా ఖచ్చితంగా అనుకుంటున్నాను.

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
ఇది, i = i -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 i = i * 2 మాట్లాడుతూ అదే విషయం,

389
00:23:57,000 --> 00:23:59,000
మరియు విభజన ఒకే విషయం.

390
00:23:59,000 --> 00:24:08,000
మీరు i / = 2 చేస్తే అది i = i / 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
అప్పుడు తిరిగి టైప్ Int అని అన్నారు.

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
probably మీరు ఒక కారకమైన గణించడానికి ఒక సంఖ్య అవసరం.

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
అన్ని మొదటి, తిరిగి టైప్ Int అవతరిస్తుంది

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
మరియు అప్పుడు, Int nums కు, అర్రే కూడా తీసుకోవాలని జరగబోతోంది

442
00:26:54,000 --> 00:26:58,000
తరువాత నేను సంకలనం ఎన్ని సంఖ్యలు తెలుసు కాబట్టి శ్రేణి యొక్క పొడవు.

443
00:26:58,000 --> 00:27:02,000
అప్పుడు నేను 0 to ఉదాహరణకు ఒక వేరియబుల్ అని మొత్తం, ప్రారంభించడం కలిగి

444
00:27:02,000 --> 00:27:08,000
మరియు నేను శ్రేణి ఒక మూలకం చూడండి ప్రతి సమయం నేను మొత్తం జోడించడానికి ఉండాలి, నేను లూప్ ఒక చేశాడు.

445
00:27:08,000 --> 00:27:15,000
Lexi చెప్పారు వలె, మీరు Int i = 0, i <పొడవు మరియు నేను + +.

446
00:27:15,000 --> 00:27:20,000
మరియు యెరే నందలి ప్రతి మూలకం కోసం నేను మొత్తం + = nums [i] చేసాడు,

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 to = అయితే అప్పుడు 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
నేను నిజానికి నేను లేదు అని IFS లోపలి వెళుతున్న

465
00:28:33,000 --> 00:28:38,000
నేను ఇప్పటికే ఈ పరిస్థితులు ఏవైనా సంతృప్తి మాత్రం కాదు తెలుసు ఎందుకంటే.

466
00:28:38,000 --> 00:28:41,000
నేను ప్రకటన else, ఉంటే వేరే ఉంటే ఉపయోగించవచ్చు.

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
విలువ అప్పుడు, విలువ 1 అని నేను దీన్ని వెళుతున్న ఉంది

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
ఈ మేము, et సెటేరా crypto, స్కోప్, శ్రేణులు, కవరింగ్ వస్తుంది విషయాలు ఉన్నాయి.

501
00:30:45,000 --> 00:30:49,000
Crypto కేవలం శీఘ్ర పదం. మేము ఈ Home హామర్ వెళ్ళి లేదు.

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
వర్ణమాల అక్షరాలను సంఖ్య ద్వారా మీరు mod చూసుకోవాలి.

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
>> మీరు ఇక్కడ ఒక ఫంక్షన్ కలిగి ఉంటే, ఉదాహరణకు, ఈ ఫంక్షన్ g కలిగి

523
00:31:53,000 --> 00:31:56,000
మరియు G లోపలి 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
CI యొక్క ఇన్సైడ్ హలో, 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
మేము asymptotic సంజ్ఞామానం అనే ఆ సూచిస్తాయి.

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
కాబట్టి మేము అమలు సమయం వివరిస్తుంది మొదటి మార్గం పెద్ద O. తో

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
మరియు మీరు ఏ కారకమైన అల్గోరిథం యొక్క ఒక O రాస్తున్నాం ఉంటే,

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
నేను ఒక O (n) అని అల్గోరిథం, మరియు ఇతరులు కలిగి అయితే

666
00:39:57,760 --> 00:40:03,590
O యొక్క ఒక అల్గోరిథం (2N) ఈ వాస్తవానికి asymptotically సమానమైన ఉన్నాయి.

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 వారు O (n) ఉన్నారు ఇలా ఒకటే వై సో ఆ.

674
00:40:32,480 --> 00:40:37,490
మేము 2 ఇతర పరుగుల సార్లు ఉంటే అదేవిధంగా, O (n ³ + 2N ²), మేము జోడించవచ్చు సే తెలియజేయండి

675
00:40:37,490 --> 00:40:42,070
అప్పుడు + n, + 7, మరియు మేము కేవలం O మరొక రన్ టైం (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
>> మేము O (n ³) మరియు O వంటి సార్లు అమలు కలిగి ఉంటే అదే విషయం కాదు (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
కాబట్టి అని చెత్త సందర్భంలో, ఈ O (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
ఈ విధంగా, జాబితా యొక్క midpoint ప్రతి అడుగు మరియు మేము చూడండి ప్రతి సమయం,

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
>> Pseudocode లో ఈ, ఈ వంటి ఏదో చూస్తారు

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 (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
మేము వెళ్ళే మొదటి విషయం ఈ జాబితాలో midpoint కనుగొనేందుకు ఉంది.

734
00:44:11,650 --> 00:44:15,060
ఇది కేవలం కాబట్టి, midpoint ఈ 2 సంఖ్యలను మధ్య పడిన అన్నారు జరిగితే

735
00:44:15,060 --> 00:44:18,960
కాబట్టి, midpoint 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
>> మరలా, ఈ midpoint ఉంది; యొక్క కేవలం చుట్టుముట్టటమే తెలియజేయండి.

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
>> ఈ యొక్క రన్ టైం O ఉండబోతుంది (n ²). ఎందుకు?

761
00:45:57,230 --> 00:46:00,370
Well, చెత్త విషయంలో ఎందుకంటే, మేము ప్రతి మూలకం తీసుకుంటున్నానని, మరియు మీరు

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
లేదా మొదటి, యొక్క కేవలం నిజంగా త్వరగా కొన్ని pseudocode చూద్దాం.

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
ఈ యొక్క రన్ టైం O ఉండబోతుంది (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 యొక్క తీట ఉంటే ², రెండు పెద్ద O (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
కాబట్టి ఈ ఎంపిక విధమైన కోసం pseudocode ఎలా అనే దాని ఉంది.

827
00:50:06,610 --> 00:50:10,630
మేము ప్రధానంగా నేను జాబితా పై iterate చేయదలిచిన చెప్పడానికి వెళుతున్న

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
కాబట్టి మేము సరే, మేము స్థానం i ఉన్నాము, మరియు మేము వద్ద అన్ని మూలకాల చూడవలసిన అవసరం, అన్నాడు

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 అనే చర్య మరియు 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
అప్ మేము మా బేస్ సందర్భాన్ని ఇక్కడ అగ్ర.

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
Well, మేము ఇప్పుడు ఈ జాబితాలో ఎడమ అర్ధ చూడండి; 1337 ద్వారా కనుక అది 15 తో విభజించిన మరియు సేమ్.

947
00:58:14,560 --> 00:58:19,020
కాబట్టి ఇప్పుడు మేము ఆ Original జాబితా, 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
సంక్లిష్టత? సరే, మీరు, ప్రతి దశ ముగింపు సంఖ్యలు అక్కడ చూడగలరు

978
01:00:24,260 --> 01:00:27,590
మరియు మేము, సగం లాగ్ n కాలంలో జాబితా తిరగడానికి చేయవచ్చు

979
01:00:27,590 --> 01:00:31,700
మేము ఈ n x లాగ్ n సంక్లిష్టత చోటే ఇది.

980
01:00:31,700 --> 01:00:34,940
మరియు మీరు విలీనంతో విధమైన ఉత్తమ కేసు N log N ఉంది చూస్తారు, మరియు ఇది కేవలం కాబట్టి జరుగుతుంది

981
01:00:34,940 --> 01:00:39,340
విషయంలో, లేదా అక్కడ Ω, కూడా n n లాగిన్ ఆ.

982
01:00:39,340 --> 01:00:42,480
గుర్తుపెట్టుకోవలసిన ఏదో.

983
01:00:42,480 --> 01:00:45,750
వెళ్లడానికి, కొన్ని సూపర్ ప్రాథమిక ఫైల్ I / O వారికి న వీడలేదు

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
Well, మేము 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
Well, ప్రారంభ కోడ్, మనం కలిగి, ఇక్కడ పైగా కోడ్ ఈ భాగం ఉంది

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
మేము, వారు దీనిని భర్తీ ఫైల్ చివర కలపవచ్చు, ఇది ఒక ఒక తరలిస్తారు

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
>> ప్రాథమిక ఫైల్ ఏ ప్రశ్నలు I / 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 ఇవ్వాలని ఉంటే సరే, అది executable అదే డైరెక్టరీనందు ఇది సృష్టిస్తుంది.

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
టామీ పేర్కొన్నారు కనుక - OH, బాగా, మరియు మేము నేను రెండో చూస్తారు ఈ ఇతర 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
Well, ప్రధాన కాల్స్ 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
Well, టెక్స్ట్ భాగమైన టాప్, ప్రోగ్రామ్ కూడా ఉంది.

1035
01:04:03,110 --> 01:04:06,390
యంత్రం కోడ్ కాబట్టి, అక్కడ, మీరు మీ కార్యక్రమాన్ని కంపైల్.

1036
01:04:06,390 --> 01:04:08,520
తరువాత, ఏ ప్రపంచ వేరియబుల్స్ initialized.

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 ఉన్న ఏదైనా అవినియోగిత ప్రపంచ డేటా కలిగి

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
కాబట్టి ఈ డిక్లేర్డ్ కాని initialized లేదు ఏ ప్రపంచ వేరియబుల్స్ అర్థం.

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-bit వ్యవస్థ మీద అయితే,

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-bit వ్యవస్థలు, అన్ని 32-bit వ్యవస్థ మీద గమనికలు 32 బిట్స్ లేదా 4 బైట్లు పడుతుంది.

1065
01:06:01,810 --> 01:06:06,020
కానీ, ఉదాహరణకు, ఒక 64-bit వ్యవస్థ మీద, గమనికలు 64 బిట్స్ ఉంటాయి.

1066
01:06:06,020 --> 01:06:08,040
తద్వారా మీరు గుర్తుంచుకోండి చెయ్యవచ్చును ఏదో ఉంది.

1067
01:06:08,040 --> 01:06:12,310
కాబట్టి ముగింపు-bit వ్యవస్థ మీద, ఒక పాయింటర్ ముగింపు బిట్స్ పొడవుగా ఉంది.

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 యొక్క పరిమాణం, ఈ 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
గమనికలు కాబట్టి మరింత. Well, 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
మరియు మేము ఈ ఆంపర్సండ్ చిహ్నం ఉపయోగిస్తున్నప్పుడు, ఈ మరియు ఆపరేటర్లు, ఏ అది ఉంది

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 మిలియన్ ల తో Firefox చూసిన ఉంటే,

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
Well, అంక గణితానికి వ్యూహం లోకి వంటి ఇండెక్సింగ్ యొక్క విధమైన ఉంది.

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
మరియు మేము Z. వాటిని సెట్ చేస్తున్నాము

1189
01:14:09,900 --> 01:14:13,350
కాబట్టి, Int కోసం i = 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
ఒక Z. మరియు ఆ మార్పులు విలువ

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
మీరు మొత్తం స్ట్రింగ్% s ఆశిస్తున్నట్లు ముద్రించాలా చేస్తే, ఒక చిరునామా

1253
01:17:54,180 --> 01:17:57,610
మరియు ఈ సందర్భంలో ఒక పాయింటర్ లేదా అక్షరాల యొక్క శ్రేణి వంటి ఈ సందర్భంలో.

1254
01:17:57,610 --> 01:18:00,330
>> అక్షరాలు, చార్ * s, మరియు శ్రేణుల ఇదే ఉంటాయి.

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
వారు ఇదే. వారు ప్రతి ఇతర కోసం వివిధ వాక్యనిర్మాణ ఉన్నారు.

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
Xkcd హాస్య పేర్కొంది. ప్రజలు ఇప్పుడు అర్థం. అబ్బాయి.

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
Well, ఈ ఏమి ఉంది. నేను మీరు మా ఈ ద్వేషం తెలుసు.

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
Well, లుకాస్, వివిధ ఆకృతులనందు గురించి మాట్లాడింది

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
ఒక విభిన్నమైన విధానం, ఒక Int 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
Well, మీరు ఏమి మీరు ఒక 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 లోపలి వివిధ విషయాలను సూచిస్తూ యొక్క విధమైన కేవలం nice సింటాక్స్ పేర్కొనడానికి అనుమతిస్తుంది.

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
మరియు ఈ ఒక కోణంలో, కేవలం ఆకృతిని మరింత సరైనది

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 మీరు ఏమి వీలు లేదు? మీరు మీ కార్యక్రమాన్ని డీబగ్ అనుమతిస్తుంది.

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
కాబట్టి ఈ విషయంలో మీరు, OH, చుట్టూ చూసి చెప్పగలను

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
>> కూల్. ఆ క్విజ్ రివ్యూ 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]