1
00:00:00,000 --> 00:00:02,970
>> [సంగీతాన్ని]

2
00:00:02,970 --> 00:00:14,355

3
00:00:14,355 --> 00:00:15,700
>> డేవిడ్ J. మలన్: అన్ని కుడి.

4
00:00:15,700 --> 00:00:18,832
ఈ CS50 మరియు ఈ
2 వ వారం ప్రారంభంలో ఉంది.

5
00:00:18,832 --> 00:00:21,040
మరియు మీరు ఆ పై గుర్తుకు వస్తుంది
వారాల గత జంట,

6
00:00:21,040 --> 00:00:24,490
మేము కంప్యూటర్ పరిచయం చేసిన
సైన్స్ మరియు, క్రమంగా, ప్రోగ్రామింగ్.

7
00:00:24,490 --> 00:00:27,640
>> మరియు మేము ద్వారా కథ ఎలాగా మొదలయింది
స్క్రాచ్, ఆ గ్రాఫికల్ భాష

8
00:00:27,640 --> 00:00:28,990
MIT యొక్క మీడియా ల్యాబ్ నుంచి.

9
00:00:28,990 --> 00:00:30,780
ఆపై ఇటీవల
గత వారం, మేము

10
00:00:30,780 --> 00:00:34,450
ఒక higher-- ఒక పరిచయం
తక్కువ స్థాయి భాష తెలిసిన

11
00:00:34,450 --> 00:00:36,770
సి, పూర్తిగా పాఠ్య ఏదో వంటి.

12
00:00:36,770 --> 00:00:39,440
మరియు, నిజానికి, చివరిసారి మేము
ఆ సందర్భంలోనే అన్వేషించారు

13
00:00:39,440 --> 00:00:40,450
అనేక భావాలు.

14
00:00:40,450 --> 00:00:43,010
>> ఈ రీకాల్, చాలా ఉంది
మొదటి కార్యక్రమం మేము చూసాము.

15
00:00:43,010 --> 00:00:45,710
ఈ కార్యక్రమం చాలా సరళంగా,
బయటకు ముద్రిస్తుంది "హలో, ప్రపంచం."

16
00:00:45,710 --> 00:00:47,730
కానీ చాలా ఉంది
కనిపించేవాటిని మేజిక్ జరగబోతోంది.

17
00:00:47,730 --> 00:00:51,460
ఈ # ఉన్నాయి ఉంది
ఈ బ్రాకెట్లు తో.

18
00:00:51,460 --> 00:00:52,170
పూర్ణాంకానికి ఉంది.

19
00:00:52,170 --> 00:00:53,020
ఉంది (తప్ప).

20
00:00:53,020 --> 00:00:56,330
బ్రాకెట్లు గిరజాల జంట కలుపులు ఉంది,
సెమీ కోలన్, మరియు మరింత.

21
00:00:56,330 --> 00:00:58,480
>> కాబట్టి, ఆ గుర్తు
మేము స్క్రాచ్ పరిచయం

22
00:00:58,480 --> 00:01:02,110
కాబట్టి మనం ఆదర్శంగా గత చూడండి
వాక్యనిర్మాణం, నిజంగా కాదు ఆ విషయాన్ని

23
00:01:02,110 --> 00:01:04,590
అన్ని మేధస్సును
ఆసక్తికరమైన కానీ ప్రారంభ

24
00:01:04,590 --> 00:01:07,700
ఖచ్చితంగా, ఒక బిట్ గమ్మత్తైన
మీ మనస్సు చుట్టూ.

25
00:01:07,700 --> 00:01:10,860
మరియు, నిజానికి, అత్యంత సాధారణమైన
ప్రారంభంలో ఒక ప్రోగ్రామింగ్ తరగతి లో విషయాలు

26
00:01:10,860 --> 00:01:13,443
ముఖ్యంగా ఆ తక్కువ కోసం
సౌకర్యవంతమైన, వేదన చేసుకోవాలని ఉంది

27
00:01:13,443 --> 00:01:17,460
మరియు కొన్ని వాక్యనిర్మాణ ద్వారా జారారు
లోపాలు, తార్కిక లోపాలు చెప్పలేదు.

28
00:01:17,460 --> 00:01:19,800
కాబట్టి మా లక్ష్యాలలో ఒకటిగా
నేడు, నిజానికి, రెడీ

29
00:01:19,800 --> 00:01:23,280
కొన్ని మీకు యంత్రాంగ ఉండాలి
ఎలా సమస్యా పూరణం పద్ధతులు

30
00:01:23,280 --> 00:01:26,705
మంచి సమస్యలు వారే పరిష్కరించడానికి
డీబగ్గింగ్ రూపంలో.

31
00:01:26,705 --> 00:01:29,330
మరియు మీరు చాలా, గుర్తుకు వస్తుంది అని,
మన పరిచయం వాతావరణంలో

32
00:01:29,330 --> 00:01:31,780
చివరిసారి CS50 IDE అని పిలిచేవారు.

33
00:01:31,780 --> 00:01:34,850
ఈ వెబ్ ఆధారిత సాఫ్ట్వేర్ అని
మీరు క్లౌడ్ కార్యక్రమానికి అనుమతిస్తుంది,

34
00:01:34,850 --> 00:01:38,450
అన్ని ఉంచుతూ, మాట్లాడటానికి మీ
మేము మళ్ళీ నేడు, కలిసి ఫైళ్లు.

35
00:01:38,450 --> 00:01:41,480
మరియు ఆ మేము గుర్తు
ఇక్కడ ఈ విషయాలు గుర్తుచేసుకున్నాడు,

36
00:01:41,480 --> 00:01:44,480
వాటిలో విధులు, మరియు ఉచ్చులు, మరియు
వేరియబుల్స్ మరియు బూలియన్ వ్యక్తీకరణలు,

37
00:01:44,480 --> 00:01:45,110
మరియు పరిస్థితులు.

38
00:01:45,110 --> 00:01:49,190
మరియు మేము నిజానికి మరికొన్ని
స్క్రాచ్ ప్రపంచం అనువాదం

39
00:01:49,190 --> 00:01:50,800
సి ప్రపంచానికి

40
00:01:50,800 --> 00:01:53,220
>> కానీ ప్రాథమిక భవనం
బ్లాక్స్, మాట్లాడటానికి,

41
00:01:53,220 --> 00:01:55,150
నిజంగా ఇప్పటికీ అదే చివరి వారం ఉన్నాయి.

42
00:01:55,150 --> 00:01:57,900
నిజానికి, మేము నిజంగా కేవలం ఒక కలిగి
వివిధ పజిల్ ముక్క, మీరు రెడీ ఉంటే.

43
00:01:57,900 --> 00:02:00,300
బదులుగా ఆ ఊదా
బ్లాక్ సేవ్ మేము బదులుగా

44
00:02:00,300 --> 00:02:02,940
ఇది printf చేసింది
సి లో ఈ ఫంక్షన్

45
00:02:02,940 --> 00:02:05,890
మీరు ఏదో ప్రింట్ అనుమతిస్తుంది
మరియు తెరపై దానిని ఫార్మాట్.

46
00:02:05,890 --> 00:02:07,950
మేము CS50 పరిచయం
లైబ్రరీ, ఇక్కడ మీరు

47
00:02:07,950 --> 00:02:11,420
మీ పారవేయడం get_char ఇప్పుడు కలిగి,
మరియు get_int, మరియు get_string,

48
00:02:11,420 --> 00:02:14,610
మరియు కొన్ని ఇతర విధులు
బాగా, ఇది ద్వారా మీరు ఇన్పుట్ పొందవచ్చు

49
00:02:14,610 --> 00:02:16,260
యూజర్ యొక్క సొంత కీబోర్డ్ నుండి.

50
00:02:16,260 --> 00:02:20,640
మరియు మేము కూడా విషయాలను పరిశీలించి పట్టింది
these- bool, మరియు చార్ వంటి

51
00:02:20,640 --> 00:02:22,490
మరియు డబుల్, ఫ్లోట్,
Int, long_long స్ట్రింగ్.

52
00:02:22,490 --> 00:02:25,170
C. మరియు ఇతర డేటా రకాలు వార్తలు

53
00:02:25,170 --> 00:02:28,560
>> ఇతర మాటలలో, మీరు ప్రకటిస్తాయి
కొన్ని విలువ నిల్వ వేరియబుల్,

54
00:02:28,560 --> 00:02:32,600
లేదా మీరు ఒక ఫంక్షన్ అమలు చేసినప్పుడు
కొన్ని విలువ తిరిగి

55
00:02:32,600 --> 00:02:35,290
మీరు ఏమి పేర్కొనవచ్చు
అని విలువ రకం.

56
00:02:35,290 --> 00:02:37,310
ఒక వంటి, ఒక స్ట్రింగ్ ఉంది
అక్షరాలు క్రమం?

57
00:02:37,310 --> 00:02:39,490
పూర్ణాంకం వంటి, అది ఒక సంఖ్య ఉంది?

58
00:02:39,490 --> 00:02:41,390
అది ఒక ఫ్లోటింగ్ పాయింట్ ఉంది
విలువ, లేదా వంటి?

59
00:02:41,390 --> 00:02:46,180
కాబట్టి సి లో, స్క్రాచ్ కాకుండా, మేము నిజానికి
ఏ రకమైన డేటా తెలుపుటకు ప్రారంభమైంది

60
00:02:46,180 --> 00:02:48,330
మనం తిరిగి లేదా ఉపయోగించి చేయబడ్డాయి.

61
00:02:48,330 --> 00:02:51,910
>> కానీ, వాస్తవానికి, మేము కూడా పడింది
కంప్యూటింగ్ యొక్క కొన్ని ప్రాథమిక పరిమితులు.

62
00:02:51,910 --> 00:02:54,100
మరియు ముఖ్యంగా,
ఈ భాష సి, రీకాల్

63
00:02:54,100 --> 00:02:57,070
మేము వద్ద ఒక లుక్ పట్టింది
పూర్ణాంక ఓవర్ఫ్లో, రియాలిటీ

64
00:02:57,070 --> 00:03:00,460
మీరు మాత్రమే ఒక కలిగి ఉంటే
మెమరీ పరిమిత మొత్తం

65
00:03:00,460 --> 00:03:04,600
లేదా, ప్రత్యేకంగా, ఒక పరిమిత సంఖ్య
బిట్స్, మీరు మాత్రమే చాలా ఎక్కువగా పరిగణించవచ్చు.

66
00:03:04,600 --> 00:03:08,460
కాబట్టి మేము ఇక్కడ ఈ ఉదాహరణ చూశారు
దీనిద్వారా ఒక విమానం లో ఒక కౌంటర్,

67
00:03:08,460 --> 00:03:13,510
నిజానికి దీర్ఘకాలం నడుస్తున్న ఉంటే అవుతుంది
ఓవర్ఫ్లో మరియు ఒక సాఫ్ట్వేర్ ఫలితంగా

68
00:03:13,510 --> 00:03:15,560
యదార్ధ భౌతిక సంభావ్య లోపం.

69
00:03:15,560 --> 00:03:18,600
>> మేము కూడా ఫ్లోటింగ్ చూశారు
పాయింట్ ఖచ్చితంగా చెప్పలేని, రియాలిటీ

70
00:03:18,600 --> 00:03:22,280
ఆ కేవలం పరిమిత సంఖ్యలో
బిట్స్, ఇది 32 లేదా 64 కావచ్చు

71
00:03:22,280 --> 00:03:27,330
మీరు మాత్రమే చాలా సంఖ్యలు పేర్కొనవచ్చు
ఒక దశాంశ బిందువు తర్వాత తర్వాత మీరు

72
00:03:27,330 --> 00:03:29,110
అస్పష్టమైన పొందడానికి ప్రారంభం.

73
00:03:29,110 --> 00:03:32,360
కాబట్టి ఉదాహరణకు, ఒక వంతు
ఇక్కడ ప్రపంచ, మా మానవ ప్రపంచంలో,

74
00:03:32,360 --> 00:03:35,360
మేము కేవలం ఒక అనంతమైన ఉంది తెలుసు
దశాంశ బిందువు తర్వాత 3S యొక్క.

75
00:03:35,360 --> 00:03:38,820
కానీ ఒక కంప్యూటర్ తప్పనిసరిగా కాదు
సంఖ్యలు అనంతమైన సంఖ్య ప్రాతినిధ్యం

76
00:03:38,820 --> 00:03:42,590
మీరు మాత్రమే అనుమతిస్తాయి ఉంటే కొన్ని
సమాచార పరిమిత మొత్తం.

77
00:03:42,590 --> 00:03:45,900
>> సో మాత్రమే మేము మీరు సిద్ధం చేయలేదు
పరంగా ఎక్కువ శక్తి తో

78
00:03:45,900 --> 00:03:49,280
యొక్క మీరు మీ వ్యక్తం ఎలా
ప్రోగ్రామింగ్ పరంగా ఒక కీబోర్డ్,

79
00:03:49,280 --> 00:03:51,430
మేము కూడా పరిమితం ఏమి
మీరు దీన్ని చేయవచ్చు.

80
00:03:51,430 --> 00:03:55,790
నిజానికి, దోషాలు మరియు తప్పులు చెయ్యవచ్చు
సమస్యలు కొన్ని రకాల నుండి తలెత్తుతాయి.

81
00:03:55,790 --> 00:03:59,900
నిజానికి, విషయాలు మధ్య నేడు
డీబగ్గింగ్ వంటి అంశాలపై ఉంటాయని

82
00:03:59,900 --> 00:04:03,699
మరియు వాస్తవానికి హుడ్ కింద చూస్తున్న
గత వారం విషయాలు పరిచయం చూసి

83
00:04:03,699 --> 00:04:05,490
వాస్తవానికి అమలు చేస్తారు
మీరు మంచి తద్వారా

84
00:04:05,490 --> 00:04:10,530
అర్థం రెండు సంస్థల సామర్ధ్యాలు మరియు
సి వంటి భాష యొక్క పరిమితుల

85
00:04:10,530 --> 00:04:14,770
>> నిజానికి, మేము తిరిగి చర్మము పొరలు చేస్తాము
డేటా నిర్మాణం సరళమైన,

86
00:04:14,770 --> 00:04:17,756
వ్యూహం అని ఏదో, ఇది
స్క్రాచ్ ఒక కాల్ ఏమవుతుంది "జాబితాలో."

87
00:04:17,756 --> 00:04:19,589
ఇది కొద్దిగా
ఆ సందర్భంలో వివిధ.

88
00:04:19,589 --> 00:04:23,340
మరియు తర్వాత మేము కూడా ఒకటి పరిచయం చేస్తాము
మొదటి మా డొమైన్ నిర్దిష్ట సమస్యలను

89
00:04:23,340 --> 00:04:26,790
CS50 లో, ప్రపంచంలో
గూఢ లిపి శాస్త్రం, స్క్రాంబ్లింగ్ యొక్క కళ

90
00:04:26,790 --> 00:04:29,650
లేదా సమాచారాన్ని ciphering లో
మీరు రహస్య సందేశాలను పంపగల

91
00:04:29,650 --> 00:04:34,520
మరియు రహస్య సందేశాలను డీకోడ్
రెండు వ్యక్తులు, A మరియు B ల మధ్య

92
00:04:34,520 --> 00:04:37,490
>> కాబట్టి మార్పుని ముందు
కొత్త ప్రపంచానికి,

93
00:04:37,490 --> 00:04:42,059
యొక్క కొన్ని మీకు యంత్రాంగ ప్రయత్నించండి తెలపండి
ఇది పద్ధతులను తీసివేయవచ్చు

94
00:04:42,059 --> 00:04:43,850
లేదా కనీసం కొన్ని తగ్గించడానికి
నిస్పృహతో

95
00:04:43,850 --> 00:04:46,630
మీరు బహుశా ఎదుర్కొన్నాము
ఒంటరిగా గత వారం కంటే.

96
00:04:46,630 --> 00:04:50,830
నిజానికి, ముందుకు మీరు కొన్ని such-- ఉంటాయి
సి అసమానత మీ మొదటి సమస్యలు ఉన్నాయి

97
00:04:50,830 --> 00:04:54,010
మీరు నా లాంటి అయితే, మొదటి సారి
మీరు ఒక ప్రోగ్రామ్ టైప్ చేయడానికి ప్రయత్నించండి,

98
00:04:54,010 --> 00:04:57,330
మీరు తార్కికంగా ఆలోచించడం కూడా
కార్యక్రమం, అందంగా సులభం

99
00:04:57,330 --> 00:05:01,200
మీరు చాలా బాగా ఒక గోడ హిట్, మరియు ఉండవచ్చు
కంపైలర్ సహకరించిన ఉండదని.

100
00:05:01,200 --> 00:05:03,940
తయారు లేదా గణగణమని ద్వని చేయు ఉండదని
నిజానికి మీ బిడ్డింగ్ చేయడానికి.

101
00:05:03,940 --> 00:05:05,450
>> ఎందుకు అని ఉంటుంది?

102
00:05:05,450 --> 00:05:07,950
సరే, పరిశీలించి వీలు,
బహుశా, ఒక సాధారణ ప్రోగ్రామ్.

103
00:05:07,950 --> 00:05:11,190
నేను ముందుకు వెళ్లి ఈ సేవ్ వెళుతున్న
ఉద్దేశపూర్వకంగా buggy0.c పిలువబడే ఒక ఫైల్,

104
00:05:11,190 --> 00:05:13,590
నేను దానిని తెలుసు ఎందుకంటే
ముందుగానే దోషపూరిత ఉంటుంది.

105
00:05:13,590 --> 00:05:17,400
కానీ నేను గుర్తించడం లేదు ఉండవచ్చు ఉంటే ఈ
మొదటి లేదా రెండవ లేదా మూడవ ప్రోగ్రామ్ ఉంది

106
00:05:17,400 --> 00:05:18,830
నేను నిజానికి నాకు తయారు చేస్తున్నాను అని.

107
00:05:18,830 --> 00:05:23,820
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
టైప్, Int ప్రధాన (తప్ప).

108
00:05:23,820 --> 00:05:28,130
నా గిరజాల జంట కలుపులు లోపలి అప్పుడు,
ఒక బాగా తెలిసిన ( "హలో, ప్రపంచం

109
00:05:28,130 --> 00:05:30,980
బాక్ స్లాష్, n ") - మరియు ఒక సెమీ కోలన్.

110
00:05:30,980 --> 00:05:32,360
>> నేను ఫైలు సేవ్ చేసిన.

111
00:05:32,360 --> 00:05:34,850
ఇప్పుడు నేను డౌన్ వెళ్ళి వెళుతున్న
నా టెర్మినల్ విండో

112
00:05:34,850 --> 00:05:40,340
మరియు రకం తయారు buggy0, ఎందుకంటే, మళ్లీ,
నేటి ఫైలు పేరు buggy0.c ఉంది.

113
00:05:40,340 --> 00:05:43,660
నేను, buggy0 చేయడానికి ఎంటర్ టైప్ చేయండి.

114
00:05:43,660 --> 00:05:48,200
>> మరియు, OH, అబ్బా, చివరిసారి నుండి గుర్తు
ఏ లోపం సందేశాలు ఒక మంచి విషయం.

115
00:05:48,200 --> 00:05:49,740
అందువలన అవుట్పుట్ ఒక మంచి విషయం.

116
00:05:49,740 --> 00:05:52,920
కానీ ఇక్కడ నేను స్పష్టంగా
పొరపాట్లు కొన్ని సంఖ్య.

117
00:05:52,920 --> 00:05:56,470
>> అవుట్పుట్ మొదటి రేఖ కాబట్టి
buggy0 చేయడానికి టైప్ తర్వాత, రీకాల్,

118
00:05:56,470 --> 00:05:59,540
గణగణమని ద్వని చేయు యొక్క బొత్తిగా వాచాల అవుట్పుట్ ఉంది.

119
00:05:59,540 --> 00:06:02,067
హుడ్ కింద,
CS50 IDE కన్ఫిగర్

120
00:06:02,067 --> 00:06:04,150
యొక్క మొత్తం బంచ్ ఉపయోగించడానికి
ఈ కంపైలర్ తో ఎంపికలు

121
00:06:04,150 --> 00:06:05,941
కాబట్టి మీరు లేని
వాటి గురించి ఆలోచించాలి.

122
00:06:05,941 --> 00:06:08,840
మరియు అన్ని మొదటి రేఖ వార్తలు
గణగణమని ద్వని చేయు తో ప్రారంభమయ్యే అంటే.

123
00:06:08,840 --> 00:06:11,720
>> అయితే ఆ తర్వాత సమస్యలు
వారి ప్రదర్శన ప్రారంభం.

124
00:06:11,720 --> 00:06:17,390
లైన్ 3, పాత్ర Buggy0.c
5, ఒక పెద్ద, ఎరుపు లోపం ఉంది.

125
00:06:17,390 --> 00:06:18,380
అది ఏమిటి?

126
00:06:18,380 --> 00:06:23,562
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ ప్రకటించారు
రకం Int (కాన్స్ట్ చార్ * తో printf,

127
00:06:23,562 --> 00:06:26,050
...) [-Werror].

128
00:06:26,050 --> 00:06:28,379
నేను చాలా త్వరగా అర్థం, అది
చాలా మర్మమైన పొందుతాడు.

129
00:06:28,379 --> 00:06:30,170
మరియు ఖచ్చితంగా, వద్ద మొదటి
చూపులో, మేము కాదు

130
00:06:30,170 --> 00:06:32,380
మీరు అర్థం ఆశించే
ఆ సందేశం యొక్క సంపూర్ణంగా.

131
00:06:32,380 --> 00:06:34,213
కాబట్టి పాఠాలు ఒకటి
నేటి అన్నారు

132
00:06:34,213 --> 00:06:36,919
గమనించే ప్రయత్నించండి ఉండాలి
నమూనాలను, లేదా ఇలాంటి విషయాలు,

133
00:06:36,919 --> 00:06:38,960
లోపాలకు మీరు కలిగి ఉండవచ్చు
గతంలో ఎదుర్కొంది.

134
00:06:38,960 --> 00:06:41,335
కాబట్టి యొక్క మాత్రమే కాకుండా బాధించటం తెలియజేయండి
తెలిసిన చూడండి ఆ ఆ పదాలు.

135
00:06:41,335 --> 00:06:44,290
పెద్ద, ఎరుపు లోపం స్పష్టంగా
ఏదో ప్రతీకగా తప్పు ఉండటం.

136
00:06:44,290 --> 00:06:47,940
>> పరిపూర్ణంగా ప్రకటించారు
printf లైబ్రరీ ఫంక్షన్.

137
00:06:47,940 --> 00:06:51,680
కాబట్టి నేను చాలా అర్థం చేయకున్నా ఏమి
పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్

138
00:06:51,680 --> 00:06:54,900
అంటే, తప్పనిసరిగా సమస్యను
ఏదో printf సంబంధించినది.

139
00:06:54,900 --> 00:06:59,130
మరియు ఆ సమస్య యొక్క మూలాన్ని
ప్రకటించుకున్నారు సంబంధం కలిగి.

140
00:06:59,130 --> 00:07:02,440
>> ప్రకటించుకున్నారు ఒక ఫంక్షన్ ఉంది
మొదటి సారి అది ప్రస్తుతించారు.

141
00:07:02,440 --> 00:07:06,210
మరియు మేము గత వారం పదజాలాన్ని ఉపయోగించారు
ఒక ఫంక్షన్ యొక్క నమూనా ప్రకటించే,

142
00:07:06,210 --> 00:07:11,860
గాని ఎగువన ఒక లైన్ తో మీ
స్వంత ఫైల్ లేదా ఒక అని పిలవబడే శీర్షిక ఫైలులో.

143
00:07:11,860 --> 00:07:15,300
ఏ లో ఫైలు మేము చెప్పటానికి లేదు
గత వారం printf కోట్ అని,

144
00:07:15,300 --> 00:07:17,080
unquote, ప్రకటించింది?

145
00:07:17,080 --> 00:07:20,950
ఏమి ఫైలు దాని నమూనా ఉంది?

146
00:07:20,950 --> 00:07:24,640
>> కాబట్టి మీరు గుర్తు, మొట్టమొదటి విషయం నేను
టైప్ చేసిన దాదాపు ప్రతి కార్యక్రమం చివరిసారి

147
00:07:24,640 --> 00:07:30,790
మరియు అనుకోకుండా ఒక క్షణం క్రితం ప్రారంభమైంది
myself-- టైప్ ఈ ఒక ఇక్కడ ఉంది

148
00:07:30,790 --> 00:07:38,630
హాష్ # ఉన్నాయి <కోసం stio--
ఇన్పుట్ / output-- డాట్ h నిజానికి,

149
00:07:38,630 --> 00:07:41,860
నేను ఇప్పుడు ఈ ఫైలు సేవ్ ఉంటే, నేను వెళుతున్న
ముందుకు వెళ్లి నా స్క్రీన్ క్లియర్,

150
00:07:41,860 --> 00:07:44,740
మీరు టైప్ ద్వారా చేయవచ్చు ఇది
ప్రశాంతంగా, లేదా మీరు కంట్రోల్ L జరపవచ్చని,

151
00:07:44,740 --> 00:07:47,680
మీ టెర్మినల్ విండో క్లియర్
కొన్ని అయోమయ తొలగించడానికి.

152
00:07:47,680 --> 00:07:51,370
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
రీ-రకం తయారు buggy0 నమోదు చేయండి.

153
00:07:51,370 --> 00:07:53,790
మరియు voila, నేను ఇప్పటికీ ఆ చూడండి
గణగణమని ద్వని చేయు నుండి దీర్ఘ ఆదేశం,

154
00:07:53,790 --> 00:07:55,470
కానీ ఏ దోష సందేశం ఈ సమయం లేదు.

155
00:07:55,470 --> 00:07:58,800
నిజానికి, నేను ./buggy0 లేకపోతే,
కేవలం చివరిసారి వంటి,

156
00:07:58,800 --> 00:08:01,860
పేరు డాట్ దీనర్థం
డైరెక్టరీ స్లాష్ కేవలం, అనగా

157
00:08:01,860 --> 00:08:05,040
ఇక్కడ కార్యక్రమం పేరు వచ్చి
కార్యక్రమం ఆ పేరు buggy0 ఉంది,

158
00:08:05,040 --> 00:08:07,340
ఎంటర్, "హలో, ప్రపంచం."

159
00:08:07,340 --> 00:08:09,440
>> ఇప్పుడు, ఎలా మీరు కలిగి ఉండవచ్చు
ఈ పరిష్కారం తీసుకోబడ్డాయి

160
00:08:09,440 --> 00:08:12,017
లేకుండా తప్పనిసరిగా
అనేక పదాలు గుర్తించడం

161
00:08:12,017 --> 00:08:14,350
నేను చేసిన విధంగా, ఖచ్చితంగా, కలిగి
చాలా సంవత్సరాలు ఈ పని?

162
00:08:14,350 --> 00:08:18,720
బాగా, మొదటి సమస్య శాతం తెలుసుకుంటారు
సెట్, మేము మీరు పరిచయం ఒక ఆదేశానికి

163
00:08:18,720 --> 00:08:21,175
CS50 యొక్క సొంత సిబ్బంది ఆ
help50 అని రాశారు.

164
00:08:21,175 --> 00:08:24,300
నిజానికి, సి కోసం వివరణ చేస్తుంది
సమస్యను ఎలా ఈ ఉపయోగించడానికి సెట్ చేయబడింది.

165
00:08:24,300 --> 00:08:27,210
>> కానీ help50 తప్పనిసరిగా ఉంది
ఒక కార్యక్రమం ఆ CS50 యొక్క సిబ్బంది

166
00:08:27,210 --> 00:08:30,850
మీరు అమలు అనుమతించే రాశారు
ఒక ఆదేశం లేదా, ఒక ప్రోగ్రామ్ అమలు

167
00:08:30,850 --> 00:08:36,169
మరియు మీరు అర్థం లేదు ఉంటే దాని
అవుట్పుట్, help50 దాని అవుట్పుట్ పాస్,

168
00:08:36,169 --> 00:08:38,890
ఇది ఒక సాఫ్టువేరు చూపుతూ
కోర్సు యొక్క సిబ్బంది రాశాడు

169
00:08:38,890 --> 00:08:42,429
మీ ప్రోగ్రామ్ యొక్క అవుట్పుట్ వద్ద కనిపిస్తాయని
లైన్ ద్వారా లైన్, పాత్ర పాత్ర.

170
00:08:42,429 --> 00:08:46,000
మరియు మేము, సిబ్బంది గుర్తించి
మీరు అనుభవిస్తున్న ఆ లోపం సందేశం,

171
00:08:46,000 --> 00:08:50,580
మేము కొన్ని మీకు రేకెత్తించి ప్రయత్నించండి
అలంకారిక ప్రశ్నలు, కొన్ని సలహా తో,

172
00:08:50,580 --> 00:08:54,890
TF లేదా సిఏ లేదా నాకు చాలా ఇష్టం
కార్యాలయం గంటల వద్ద వ్యక్తి చేయరు.

173
00:08:54,890 --> 00:08:58,320
>> మీరు లేకపోతే సో help50 చూడాల్సి
తప్పనిసరిగా ఒక సమస్య గుర్తించి.

174
00:08:58,320 --> 00:09:00,790
కానీ అది ఆధారపడి లేదు
ఒక ఊతకర్ర వలె చాలా.

175
00:09:00,790 --> 00:09:03,990
ఖచ్చితంగా అర్థం ప్రయత్నించండి దాని
అవుట్పుట్ మరియు అప్పుడు అది నేర్చుకుని

176
00:09:03,990 --> 00:09:07,571
కాబట్టి ఒకసారి లేదా రెండుసార్లు మాత్రమే మీరు చేసే
ఎప్పుడైనా ఒక దోష కోసం help50 అమలు

177
00:09:07,571 --> 00:09:08,070
సందేశం.

178
00:09:08,070 --> 00:09:10,660
ఆ తరువాత, మీరు ఉండాలి
మీరే అమర్చారు

179
00:09:10,660 --> 00:09:13,180
దొరుకుతుందని నిజానికి ఏమిటి.

180
00:09:13,180 --> 00:09:14,350
>> యొక్క ఇక్కడ ఇతర ఏమి చూద్దాం.

181
00:09:14,350 --> 00:09:20,410
నాకు ముందుకు వెళ్లి, మరో లెట్
ఫైలు మేము ఈ buggy1.c పిలుస్తాను.

182
00:09:20,410 --> 00:09:23,110
మరియు ఈ ఫైలులో నేను
deliberately-- అన్నారు

183
00:09:23,110 --> 00:09:26,330
కానీ నేను లేదు నటిస్తారు
నేను చేసిన ఏమి తప్పు అర్థం.

184
00:09:26,330 --> 00:09:31,420
>> నేను ముందుకు వెళ్లి దీన్ని చేయ బోతున్నాను
# ఉన్నాయి, నేను చేసిన నుండి

185
00:09:31,420 --> 00:09:33,660
ఒక క్షణం క్రితం నుండి నా పాఠం నేర్చుకున్నాడు.

186
00:09:33,660 --> 00:09:36,220
Int ప్రధాన (తప్ప), ముందు.

187
00:09:36,220 --> 00:09:40,880
ఆపై ఇక్కడ నేను వెళ్తున్నాను
స్ట్రింగ్ s చేయడానికి - get_string.

188
00:09:40,880 --> 00:09:43,770
మరియు చివరిసారి నుండి గుర్తు
ఈ మార్గాల, హే, కంప్యూటర్,

189
00:09:43,770 --> 00:09:48,280
నాకు ఒక వేరియబుల్ ఇవ్వండి దీనిని లు కాల్, మరియు
ఆ వేరియబుల్ ఒక స్ట్రింగ్ యొక్క రకం

190
00:09:48,280 --> 00:09:50,150
కాబట్టి నేను ఒకటి లేదా ఎక్కువ పదాలు నిల్వ చేయవచ్చు.

191
00:09:50,150 --> 00:09:52,191
>> ఆపై కుడి వైపు
సమాన సైన్ వైపు

192
00:09:52,191 --> 00:09:54,980
ఒక ఇది, get_string ఉంది
CS50 లైబ్రరీ ఫంక్షన్

193
00:09:54,980 --> 00:09:55,980
సరిగ్గా ఆ చేస్తుంది.

194
00:09:55,980 --> 00:09:59,740
అది ఒక ఫంక్షన్ మరియు గెట్స్
కుడి నుండి చేతులు ఇది.

195
00:09:59,740 --> 00:10:02,670
కాబట్టి ఈ సమాన సైన్ కాదు
మేము గణిత అనుకుంటున్నాను ఉండవచ్చు వంటి "సమానం".

196
00:10:02,670 --> 00:10:04,750
ఇది కుడి నుండి అప్పగించిన అర్థం.

197
00:10:04,750 --> 00:10:09,640
కాబట్టి ఈ అర్థం, నుండి స్ట్రింగ్ పడుతుంది
వినియోగదారు మరియు లు లోపలి నిల్వ.

198
00:10:09,640 --> 00:10:10,460
>> ఇప్పుడు అది ఉపయోగించడానికి అనుమతిస్తున్నట్లు.

199
00:10:10,460 --> 00:10:13,820
నాకు రెండవ ఇప్పుడు మరియు ముందుకు వెళ్ళి తెలపండి
పంక్తి, నాకు ముందుకు వెళ్లి "హలో" అని పిలవబడు -

200
00:10:13,820 --> 00:10:19,330
కాదు "ప్రపంచ", కానీ "హలో,% s--
ఇది మన హోల్డర్, కామా s,

201
00:10:19,330 --> 00:10:22,030
ఇది మా వేరియబుల్,
ఆపై ఒక సెమీ కోలన్.

202
00:10:22,030 --> 00:10:26,070
కాబట్టి నేను చాలా అప్ మేకు లేదు ఉంటే
ఇక్కడ, ఈ సరైన కోడ్ కనిపిస్తోంది.

203
00:10:26,070 --> 00:10:28,090
>> నా ప్రవృత్తులు ఇప్పుడు అది కంపైల్ ఉన్నాయి.

204
00:10:28,090 --> 00:10:30,400
ఫైలు buggy1.c అని ఉంది.

205
00:10:30,400 --> 00:10:33,770
నేను buggy1 తయారు ఎంటర్ చేయ బోతున్నాను.

206
00:10:33,770 --> 00:10:36,377
మరియు రంధ్రాన్ని సరి చేయు ఇది, అక్కడ లేకపోతే
ముందు కంటే మరింత లోపాలు.

207
00:10:36,377 --> 00:10:38,210
నా ఉద్దేశ్యం ఎక్కువ ఉంది
దోష సందేశాలు వచ్చే కాలం

208
00:10:38,210 --> 00:10:40,400
ఈ కార్యక్రమం లో వాస్తవ మార్గాల కన్నా కనిపిస్తుంది.

209
00:10:40,400 --> 00:10:42,730
>> కానీ తాత్కాలిక ఇక్కడ ఉంది
మీరు నిమగ్నం ఉన్నాము అయినా

210
00:10:42,730 --> 00:10:45,040
రెండు లేదా మూడు లేదా తో
నాలుగు కంటే దోష సందేశాలు,

211
00:10:45,040 --> 00:10:48,340
చాలా ఎల్లప్పుడూ దృష్టి
మొదటి ఆ సందేశాలను.

212
00:10:48,340 --> 00:10:52,220
టాప్ అత్యంత ఒకటి చూడటం,
తిరిగి అవసరం అప్ స్క్రోలింగ్ ఉంటుంది.

213
00:10:52,220 --> 00:10:53,930
ఇక్కడ నేను తయారు buggy1 టైప్.

214
00:10:53,930 --> 00:10:55,700
ఇక్కడ అనుకున్న గణగణమని ద్వని చేయు అవుట్పుట్ ఉంది.

215
00:10:55,700 --> 00:10:57,290
>> మరియు ఇక్కడ మొదటి ఎరుపు లోపం.

216
00:10:57,290 --> 00:11:02,370
అస్పష్టమైన గుర్తింపు
స్ట్రింగ్, నేను ప్రామాణిక ఉద్దేశమేమిటి?

217
00:11:02,370 --> 00:11:04,260
కాబట్టి ప్రామాణిక ఉంది
నిజానికి ఏదో.

218
00:11:04,260 --> 00:11:06,240
ఇది వినియోగదారు యొక్క సూచిస్తుంది
కీబోర్డ్, ముఖ్యంగా.

219
00:11:06,240 --> 00:11:08,080
>> కానీ నేను అర్థం కాదు.

220
00:11:08,080 --> 00:11:11,770
నేను స్ట్రింగ్ అర్ధం, మరియు నేను get_string అర్థం.

221
00:11:11,770 --> 00:11:16,200
కనుక ఇది ఏమిటి నేను
ఈ సమయంలో మర్చిపోయారు?

222
00:11:16,200 --> 00:11:20,230
ఈ సమయంలో వెలితి?

223
00:11:20,230 --> 00:11:23,600
నా # ఉన్నాయి కలిగి,
కాబట్టి నేను printf ప్రాప్తి.

224
00:11:23,600 --> 00:11:26,090
>> కానీ నేను ఏమి లేదు
ఇంకా యాక్సెస్?

225
00:11:26,090 --> 00:11:29,420
అయితే, నువ్వు చివరిసారి వంటి,
నేను కంపైలర్ చెప్పడానికి అవసరం

226
00:11:29,420 --> 00:11:31,691
ఏమి ఈ క్రియలు గణగణమని ద్వని చేయు.

227
00:11:31,691 --> 00:11:33,940
Get_string రాదు
C. తో మరియు ముఖ్యంగా, ఇది

228
00:11:33,940 --> 00:11:38,160
లో రాదు
, ఫైలు శీర్షిక.

229
00:11:38,160 --> 00:11:40,770
ఇది బదులుగా వస్తుంది
ఏదో సిబ్బంది రాశాడు,

230
00:11:40,770 --> 00:11:44,176
ఇది వేరే ఫైల్
పేరు కానీ సముచితంగా పేరు.

231
00:11:44,176 --> 00:11:46,990

232
00:11:46,990 --> 00:11:50,861
>> కాబట్టి కేవలం ఒక లైన్ జోడించడం ద్వారా ఆ
చివరిసారి నుండి ఉంటుంది కోడ్ రీకాల్

233
00:11:50,861 --> 00:11:53,610
గణగణమని ద్వని చేయు నడుస్తుంది ఉన్నప్పుడు, అది జరగబోతోంది
దిగువ నా కోడ్ ఎగువన చూడండి,

234
00:11:53,610 --> 00:11:54,193
ఎడమ.

235
00:11:54,193 --> 00:11:57,200
ఇది గమనించవచ్చు జరగబోతోంది
ఓహ్, మీకు కావలసిన.

236
00:11:57,200 --> 00:11:59,900
నాకు వెళ్ళి ఆ కనుగొనేందుకు లెట్,
ఇది సర్వర్లో ఎక్కడ,

237
00:11:59,900 --> 00:12:03,090
తప్పనిసరిగా కాపీ మరియు పేస్ట్,
మీ స్వంత ఫైల్ యొక్క పైభాగములో

238
00:12:03,090 --> 00:12:06,820
కాబట్టి కథ ఈ సమయంలో,
పంక్తి 1, ప్రోగ్రామ్ యొక్క మిగిలిన

239
00:12:06,820 --> 00:12:11,651
చేయవచ్చు, నిజానికి, ఫంక్షన్స్ ఏ ఉపయోగించడానికి
అందులో, వాటిలో get_string.

240
00:12:11,651 --> 00:12:13,650
నేను విస్మరించండి వెళుతున్న
ఆ లోపాలు మిగిలిన

241
00:12:13,650 --> 00:12:17,190
నేను, నిజానికి, మాత్రమే అనుమానిస్తున్నారు
మొదటి ఒకటి ఏమిటంటే ముఖ్యమని.

242
00:12:17,190 --> 00:12:20,780
మరియు నేను ముందుకు మరియు గణగణమని వెళ్ళి వెళుతున్న
నా ఫైలు సేవ్ తర్వాత buggy1 తయారు.

243
00:12:20,780 --> 00:12:22,580
మరియు voila, అది పని చేసింది.

244
00:12:22,580 --> 00:12:29,200
నేను ./buggy1 చేయండి మరియు ఉంటే, టైపు
ఉదాహరణకు, Zamyla, నేను ఇప్పుడు హలో, పొందుతారు

245
00:12:29,200 --> 00:12:32,000
Zamyla, హలో బదులుగా, ప్రపంచం.

246
00:12:32,000 --> 00:12:32,550
>> అయితే సరే.

247
00:12:32,550 --> 00:12:35,890
కాబట్టి ఇక్కడ అవేలు అప్పుడు ఉన్నాయి,
ఒకటి, ఎక్కువ మీరు చెయ్యగలరు గా కొద్ది కొద్దిగా ప్రయత్నించండి

248
00:12:35,890 --> 00:12:39,140
ఒంటరిగా లోపం సందేశాలను నుండి చూస్తున్న
గుర్తించదగిన పదాలు కొన్ని.

249
00:12:39,140 --> 00:12:43,070
ఆ నిషేధిత ప్రకారం help50 ఉపయోగించడానికి
సమస్య సెట్.

250
00:12:43,070 --> 00:12:46,500
కానీ ఆ నిషేధిత, చాలా, ఎల్లప్పుడూ చూడండి
టాప్ లోపం మాత్రమే, కనీసం

251
00:12:46,500 --> 00:12:50,051
ప్రారంభంలో, చూడటానికి ఏ సమాచారం
నిజానికి ఇచ్చు ఉండవచ్చు.

252
00:12:50,051 --> 00:12:52,300
కానీ అది ఉంది అది మారుతుంది
మరింత కార్యాచరణను నిర్మించారు

253
00:12:52,300 --> 00:12:55,030
CS50 లైబ్రరీ లోకి సహాయం
సెమిస్టర్ ప్రారంభంలో మీరు

254
00:12:55,030 --> 00:12:57,580
ప్రారంభ ప్రోగ్రామింగ్
విషయమేనా తప్పు జరగబోతోంది.

255
00:12:57,580 --> 00:12:59,840
కాబట్టి యొక్క ఇక్కడ మరొక ఉదాహరణ తెలియజేసేలా.

256
00:12:59,840 --> 00:13:04,350
నేను, ఈ buggy2 కాల్ వెళుతున్న,
మళ్ళీ, బయటకు పొరపాట్లు కావడం

257
00:13:04,350 --> 00:13:05,650
గేట్, డిజైన్ ద్వారా.

258
00:13:05,650 --> 00:13:09,980
>> మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు # ఉన్నాయి చేయండి.

259
00:13:09,980 --> 00:13:12,580
ఆపై నేను Int ప్రధాన (తప్ప) చేయ బోతున్నాను.

260
00:13:12,580 --> 00:13:14,840
ఆపై నేను లూప్ ఒక చేయ బోతున్నాను.

261
00:13:14,840 --> 00:13:16,690
కోసం (Int i _ 0.

262
00:13:16,690 --> 00:13:18,750
నేను కంటే తక్కువ లేదా 10 సమానం.

263
00:13:18,750 --> 00:13:24,260
నేను ++, మరియు అప్పుడు గిరజాల జంట కలుపులు, నేను వెళుతున్న
ఇక్కడ కేవలం ఒక హాష్ ట్యాగ్ చిహ్నం ముద్రించాలా

264
00:13:24,260 --> 00:13:25,920
మరియు ఒక కొత్త లైన్ పాత్ర.

265
00:13:25,920 --> 00:13:29,220
>> ఈ నా ఉద్దేశం కాబట్టి
కార్యక్రమం చాలా సాధారణంగా

266
00:13:29,220 --> 00:13:33,150
10 సార్లు iterate ఎలా
మరియు ప్రతి మళ్ళా న

267
00:13:33,150 --> 00:13:35,260
ఆ లూప్ ప్రతి సమయం
చక్రం ద్వారా,

268
00:13:35,260 --> 00:13:37,660
ఒక హాష్ ట్యాగ్ ప్రింట్,
ఒక హాష్ ట్యాగ్ ఒక హాష్ ట్యాగ్.

269
00:13:37,660 --> 00:13:40,480
నేను ఎందుకంటే ఒక పంక్తికి
అక్కడ కొత్త లైన్ ఉంది.

270
00:13:40,480 --> 00:13:42,787
మరియు ఆ కోసం గుర్తుకు
లూప్ గత వారం శాతం,

271
00:13:42,787 --> 00:13:44,620
మరియు మీరు మరింత పొందుతారు
వాక్యనిర్మాణం తెలిసిన

272
00:13:44,620 --> 00:13:47,170
ఆచరణలో అది ఉపయోగించి
లాంగ్ ముందు ఈ నాకు ఇస్తుంది

273
00:13:47,170 --> 00:13:49,740
ఒక వేరియబుల్ నేను అని మరియు అది 0 అమర్చుతుంది.

274
00:13:49,740 --> 00:13:52,650
>> ఈ i న ఇంక్రిమెంట్
1 ప్రతి మళ్ళా.

275
00:13:52,650 --> 00:13:54,940
నేను 3 1 వెళ్తాడు 2.

276
00:13:54,940 --> 00:13:57,690
ఆపై ఈ స్థితిలో
సెమీ కోలన్ మధ్య మధ్యలో

277
00:13:57,690 --> 00:14:03,010
చేయడానికి ప్రతి మళ్ళా న తనిఖీ తీర్చుకుంటాడు
మేము పరిధిలో పరిధిలో ఉన్నాయి నిర్ధారించుకోండి.

278
00:14:03,010 --> 00:14:06,830
కాబట్టి నేను 10 సార్లు iterate మీరు, నేను
చాలా విధమైన అకారణంగా కేవలం

279
00:14:06,830 --> 00:14:09,070
నా ఎగువ బంధం 10 ఉంచండి.

280
00:14:09,070 --> 00:14:14,310
>> మరియు ఇంకా, నేను ఈ అమలు తర్వాత,
తయారు ఇది కంపైల్ buggy2--

281
00:14:14,310 --> 00:14:15,440
మరియు అది సరే కంపైల్ లేదు.

282
00:14:15,440 --> 00:14:17,980
నేను ఒక లేదు
వాక్యనిర్మాణ దోషం ఈ సమయంలో.

283
00:14:17,980 --> 00:14:20,940
నాకు ఇప్పుడు ముందుకు వెళ్ళి తెలపండి
మరియు buggy2 అమలు నమోదు.

284
00:14:20,940 --> 00:14:22,620
ఇప్పుడు వరకు స్క్రోల్.

285
00:14:22,620 --> 00:14:24,890
మరియు నాకు పెంచడానికి వీలు
విండో యొక్క పరిమాణం.

286
00:14:24,890 --> 00:14:33,720
>> నేను కలిగి అనిపించడం 1, 2, 3,
4, 5, 6, 7, 8, 9, 10, 11.

287
00:14:33,720 --> 00:14:38,891
కాబట్టి 11 హ్యాష్ట్యాగ్ల ఉంది అయినప్పటికీ,
నేను స్పష్టంగా ఈ లూప్ యొక్క లోపల 10 ఉంచండి.

288
00:14:38,891 --> 00:14:42,140
ఇప్పుడు, మీరు కొన్ని వెంటనే చూడవచ్చు
ఏ లోపం ఎందుకంటే, నిజానికి, ఈ

289
00:14:42,140 --> 00:14:43,720
చేయడానికి ఒక చాలా హార్డ్ లోపం కాదు.

290
00:14:43,720 --> 00:14:46,070
కానీ ఇది చాలా సాధారణంగా ఉంది
చాలా ప్రారంభ చేసింది.

291
00:14:46,070 --> 00:14:49,820
>> నేను అభిప్రాయపడుతున్నారు మీరు, అయితే,
ఉంది, నేను ఎలా దొరుకుతుందని ఉండవచ్చు?

292
00:14:49,820 --> 00:14:52,300
సరే, ఆ అవుతుంది
CS50 లైబ్రరీ వస్తుంది

293
00:14:52,300 --> 00:14:55,380
మాత్రమే get_string మరియు get_int తో
మరియు get_float మరియు ఇతర విధులు.

294
00:14:55,380 --> 00:14:59,980
ఇది కూడా ఒక ప్రత్యేక ఫంక్షన్ తో వస్తుంది
eprintf అని, లేదా, లోపం printf.

295
00:14:59,980 --> 00:15:03,270
మరియు అది సంపాదించడానికి మాత్రమే ఉంది
మీరు కోసం కొద్దిగా సులభంగా

296
00:15:03,270 --> 00:15:06,310
కేవలం మీ కోడ్ డీబగ్గింగ్ చేసేటప్పుడు
తెరపై ఒక దోష సందేశం ప్రింట్

297
00:15:06,310 --> 00:15:07,850
ఎక్కడ నుండి వచ్చి తెలుసు.

298
00:15:07,850 --> 00:15:11,000
>> కాబట్టి ఉదాహరణకు, ఒక విషయం నేను వాటిని
ఇక్కడ ఏమి ఈ ఫంక్షన్ దీన్ని ఉంది

299
00:15:11,000 --> 00:15:20,230
eprintf, మరియు అప్పుడు నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు నేను ఇప్పుడు% నేను, బాక్ స్లాష్ n, అని చెబుతారు.

300
00:15:20,230 --> 00:15:22,330
నేను నేను విలువ లో ప్లగ్ వెళుతున్న.

301
00:15:22,330 --> 00:15:25,400
మరియు టాప్, ఈ ఎందుకంటే
, CS50 లైబ్రరీలో

302
00:15:25,400 --> 00:15:27,580
నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు ఉన్నాయి

303
00:15:27,580 --> 00:15:29,169
కాబట్టి నేను ఈ ఫంక్షన్ యాక్సెస్.

304
00:15:29,169 --> 00:15:31,460
కానీ యొక్క పరిశీలిద్దాం ఏ లైన్
9 చేస్తూ కోరుకుంటున్నాము.

305
00:15:31,460 --> 00:15:32,670
నేను చివరికి ఈ తొలగించండి వెళుతున్న.

306
00:15:32,670 --> 00:15:34,670
ఈ ఏమీ ఉంది
నా ప్రబలమైన లక్ష్యంతో.

307
00:15:34,670 --> 00:15:39,090
కానీ eprintf, లోపం printf, కేవలం అర్థం
నాకు కొన్ని విశ్లేషణ సమాచారం ఇవ్వాలని.

308
00:15:39,090 --> 00:15:42,460
నా ప్రోగ్రామ్ రన్, నాకిష్టమే
తాత్కాలికంగా తెరపై ఈ చూడండి

309
00:15:42,460 --> 00:15:44,550
అలాగే, కేవలం అర్థం
ఏం జరుగుతోంది.

310
00:15:44,550 --> 00:15:47,330
>> మరియు, నిజానికి, ప్రతి న
ఇక్కడ లైన్ 9 మళ్ళా

311
00:15:47,330 --> 00:15:49,260
నేను చూడాలనుకుంటే, నేను విలువ ఏమిటి?

312
00:15:49,260 --> 00:15:50,290
నేను విలువ ఏమిటి?

313
00:15:50,290 --> 00:15:51,280
నేను విలువ ఏమిటి?

314
00:15:51,280 --> 00:15:55,650
మరియు, ఆశాజనక, నేను మాత్రమే ఉండాలి
ఆ సందేశం, కూడా, 10 సార్లు చూడండి.

315
00:15:55,650 --> 00:15:57,780
>> నాలో ముందుకు వెళ్లి
నా ప్రోగ్రామ్ మళ్ళీ కంపైల్ చెయ్యండి

316
00:15:57,780 --> 00:15:59,905
నేను ఏ సమయంలో ఏమి కలిగి
నేను ఒక మార్పు. ./buggy2.

317
00:15:59,905 --> 00:16:02,680

318
00:16:02,680 --> 00:16:03,640
మరియు ఇప్పుడు సరి.

319
00:16:03,640 --> 00:16:04,820
అక్కడ ఎక్కువ జరగబోతోంది చాలా ఉంది.

320
00:16:04,820 --> 00:16:07,610
నాలో స్క్రోల్ వీలు
ఇంకా పెద్ద విండో.

321
00:16:07,610 --> 00:16:10,190
>> మీలో ప్రతి చూస్తారు
హ్యాష్ట్యాగ్ల ఇప్పటికీ ప్రింటింగ్ ఉంది.

322
00:16:10,190 --> 00:16:15,270
కానీ మధ్య వాటిని ప్రతి ఇప్పుడు ఈ
ఈ క్రింది విధంగా విశ్లేషణ అవుట్పుట్ ఫార్మాట్.

323
00:16:15,270 --> 00:16:17,960
ఇక్కడ నా ప్రోగ్రామ్ యొక్క పేరు buggy2 ఉంది.

324
00:16:17,960 --> 00:16:20,432
ఫైలు పేరు buggy2.c ఉంది.

325
00:16:20,432 --> 00:16:24,080
లైన్ నెంబర్ ఇది నుండి
ఈ ముద్రించారు లైన్ 9.

326
00:16:24,080 --> 00:16:27,500
మరియు ఆ కుడి ఉంది
నేను ఆశించే వెబ్ ఆ దోష సందేశం.

327
00:16:27,500 --> 00:16:30,701
>> మరియు nice గురించి ఆ ఇది ఏమిటి
ఇప్పుడు నేను తప్పనిసరిగా లెక్కించాలి లేదు

328
00:16:30,701 --> 00:16:32,200
నా తల లో నా ప్రోగ్రామ్ ఏమి చేస్తోంది.

329
00:16:32,200 --> 00:16:34,240
నేను చూడగలరు
నేను 0 మొదటి మళ్ళా,

330
00:16:34,240 --> 00:16:39,420
తరువాత 1, 2, 3, 4, అప్పుడు
5 అయితే అప్పుడు 6, 7, 8, అప్పుడు 9, అప్పుడు

331
00:16:39,420 --> 00:16:40,980
10.

332
00:16:40,980 --> 00:16:42,050
కాబట్టి ఒక నిమిషం ఆగండి.

333
00:16:42,050 --> 00:16:43,740
ఏమి జరుగుతుంది ఇక్కడ?

334
00:16:43,740 --> 00:16:48,190
నేను ఇప్పటికీ లెక్కింపు అనిపించడం
10 వరకు ఉద్దేశించబడింది.

335
00:16:48,190 --> 00:16:50,550
>> కానీ నేను ఎక్కడ ఎప్పటి?

336
00:16:50,550 --> 00:16:53,240
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10.

337
00:16:53,240 --> 00:16:58,040
కాబట్టి 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10-- 11 వేలు

338
00:16:58,040 --> 00:16:59,990
సమస్య సూచన ఉంది.

339
00:16:59,990 --> 00:17:02,850
నేను లెక్కిస్తారు కనిపిస్తుంది
తప్పుగా నా లూప్ లో.

340
00:17:02,850 --> 00:17:06,599
వెళ్ళి 10 నిద్రావస్థ కాకుండా,
నేను 0 వద్ద ప్రారంభమై వెబ్

341
00:17:06,599 --> 00:17:09,550
నేను మరియు 10 ద్వారా ముగించాడు చేస్తున్నాను.

342
00:17:09,550 --> 00:17:12,030
కానీ ఎందుకంటే, ఒక కంప్యూటర్ వంటి,
నేను 0 వద్ద లెక్కింపు మొదలు వెబ్,

343
00:17:12,030 --> 00:17:15,250
నేను లెక్కింపు చేయాలి
, కానీ 10 వ.

344
00:17:15,250 --> 00:17:18,510
>> కాబట్టి పరిష్కారము, నేను చివరికి
ఇక్కడ గ్రహించారు, రెండు విషయాలు ఒకటి.

345
00:17:18,510 --> 00:17:22,430
నేను చాలా కేవలం చెప్పగల్గినవి
కంటే తక్కువ 10 వరకు కౌంట్.

346
00:17:22,430 --> 00:17:27,260
కాబట్టి 0, 1, 2, 3, 4, 5, 6, 7, 8,
9, సరైన, నిజానికి,

347
00:17:27,260 --> 00:17:28,900
కూడా కొద్దిగా తప్పు ధ్వనులు అయితే.

348
00:17:28,900 --> 00:17:35,070
లేదా నేను చేయగల కంటే లేదా సమానం
9 వరకు చాలా కాలం నేను 0 వద్ద మొదలు.

349
00:17:35,070 --> 00:17:40,056
లేదా మీరు నిజంగా అది ఇష్టం లేకపోతే, మీరు
10 ద్వారా కూడుట కానీ 1 ప్రారంభించవచ్చు.

350
00:17:40,056 --> 00:17:41,680
కానీ మళ్ళీ, ఈ కేవలం ఉండటం సాధారణంగా కనిపిస్తుంది.

351
00:17:41,680 --> 00:17:43,977
programming-- అయినప్పటికీ లో
లో Scratch-- చాలా కాదు

352
00:17:43,977 --> 00:17:45,810
కానీ ప్రోగ్రామింగ్ లో
సి మరియు ఇతర భాషలు,

353
00:17:45,810 --> 00:17:47,670
JavaScript మరియు వంటి
పైథాన్ మరియు ఇతరులు, అంతే

354
00:17:47,670 --> 00:17:49,880
కేవలం చాలా సాధారణ
బైనరీ మా చర్చ

355
00:17:49,880 --> 00:17:53,450
కేవలం వద్ద లెక్కింపు ప్రారంభం
0, ఇది మీరు, అతి తక్కువ.

356
00:17:53,450 --> 00:17:53,950
అయితే సరే.

357
00:17:53,950 --> 00:17:55,160
కాబట్టి ఆ eprintf వార్తలు.

358
00:17:55,160 --> 00:17:58,600
మరియు తిరిగి, ఇప్పుడు నేను కనుగొన్నారు చేసిన నా
సమస్య, మరియు నేను 0 తిరిగి వెళ్ళడానికి వెళుతున్న

359
00:17:58,600 --> 00:18:01,470
10 కంటే తక్కువ ద్వారా, నేను వెళుతున్న
వెళ్ళి eprintf తొలగించడానికి.

360
00:18:01,470 --> 00:18:04,580
>> ఇది నేను అక్కడ ఉండకూడదు
నా కోడ్ రవాణా లేదా నా కోడ్ submit

361
00:18:04,580 --> 00:18:05,800
లేదంటే ఎవరైనా దానిని చూపించడానికి.

362
00:18:05,800 --> 00:18:07,980
ఇది నిజంగా కేవలం ఉద్దేశించబడినదిగా
తాత్కాలికంగా ఉపయోగిస్తారు.

363
00:18:07,980 --> 00:18:11,650
కానీ ఇప్పుడు నేను ఈ పరిష్కరించబడింది చేసిన
అలాగే ప్రత్యేక సమస్య.

364
00:18:11,650 --> 00:18:16,780
>> సరే, ఇక్కడ ఒకటి కంటే ఉదాహరణ తెలియజేసేలా
నేను ఈ క్రింది విధంగా అప్ రెచ్చిపోయినప్పుడు వెళుతున్న.

365
00:18:16,780 --> 00:18:22,850
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
# ఉన్నాయి. $ 50

366
00:18:22,850 --> 00:18:25,580
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు # ఉన్నాయి.

367
00:18:25,580 --> 00:18:29,030
>> నేను సేవ్ వెళుతున్న
ఈ ఫైలు buggy3.c వంటి.

368
00:18:29,030 --> 00:18:31,740
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న
డిక్లేర్ Int ప్రధాన (తప్ప).

369
00:18:31,740 --> 00:18:34,186
ఆపై అక్కడ లోపల
నేను Int ఐ చేయ బోతున్నాను _ -

370
00:18:34,186 --> 00:18:36,435
నేను ఒక కార్యక్రమం అమలు చేయదలిచిన
ఒక get_negative_int తో.

371
00:18:36,435 --> 00:18:39,146

372
00:18:39,146 --> 00:18:40,770
ఈ ఇంకా ఉనికిలో ఉన్న ఒక క్రియ కాదు.

373
00:18:40,770 --> 00:18:42,870
కాబట్టి మేము అమలు చేయబోతున్నామని
అది కేవలం ఒక క్షణం లో.

374
00:18:42,870 --> 00:18:45,541
కానీ మేము ఎందుకు చూడాలని
ఇది మొదటి పాస్ వద్ద బగ్గీ వార్తలు.

375
00:18:45,541 --> 00:18:47,290
మరియు నేను సంపాదించిన చేసిన తర్వాత
వినియోగదారు నుండి ఒక Int,

376
00:18:47,290 --> 00:18:53,365
నేను% నేను ప్రింట్ వెళుతున్న ప్రతికూల
పూర్ణాంక, బాక్ స్లాష్ n, కామా i.

377
00:18:53,365 --> 00:18:55,240
ఇతర మాటలలో, నేను
ఏమి ఈ కార్యక్రమం మీరు

378
00:18:55,240 --> 00:18:58,000
నుండి ప్రతికూల పూర్ణాంకానికి పొందండి
యూజర్ ఆపై ప్రింట్

379
00:18:58,000 --> 00:18:59,980
అలాంటి మరియు ఒక ప్రతికూల పూర్ణాంకానికి ఉంది.

380
00:18:59,980 --> 00:19:02,080
>> ఇప్పుడు నేను ఈ ఫంక్షన్ అమలు చేయాలి.

381
00:19:02,080 --> 00:19:05,740
సో తరువాత నా ఫైలు లో, నేను వెళ్ళడానికి వెళుతున్న
ముందుకు మరియు అని ఒక ఫంక్షన్ ప్రకటించాలని

382
00:19:05,740 --> 00:19:10,670
get_negative_int (తప్ప) - మరియు మేము చేస్తాము
ఆ లైన్ మళ్ళీ అర్థం ఏమి తిరిగి వచ్చి

383
00:19:10,670 --> 00:19:18,790
ఒక క్షణం పూర్ణాంకానికి n లో; అలా పనుల
కింది printf n ఉంది :.

384
00:19:18,790 --> 00:19:26,210
, Get_int - ఆపై నేను n చేయ బోతున్నాను
మరియు ఈ సమయంలో N 0 కన్నా ఎక్కువ ఉంది.

385
00:19:26,210 --> 00:19:28,310
ఆపై n తిరిగి ;.

386
00:19:28,310 --> 00:19:31,730
>> కాబట్టి జరగబోతోంది చాలా ఉంది
మేము అది ఈ కానీ ఏదీ

387
00:19:31,730 --> 00:19:33,710
కనీసం కొంతకాలం, గత వారం చూడండి.

388
00:19:33,710 --> 00:19:36,980
కాబట్టి ఇక్కడ లైన్ 10 న నేను డిక్లేర్డ్ చేసిన
get_negative_int అని ఫంక్షన్,

389
00:19:36,980 --> 00:19:39,620
మరియు నేను ఉంచాము (తప్ప),
బ్రాకెట్లు కారణం ఈ ఉండటం

390
00:19:39,620 --> 00:19:40,950
ఒక ఇన్పుట్ తీసుకోదు.

391
00:19:40,950 --> 00:19:42,910
నేను ఏదైనా అక్కడ లేదు
ఈ ఫంక్షన్ కు.

392
00:19:42,910 --> 00:19:44,690
నేను అది తిరిగి ఏదో పొందుతున్నాను.

393
00:19:44,690 --> 00:19:47,270
>> మరియు నేను ఆశతో చేస్తున్నాను
తిరిగి పొందడానికి ఒక పూర్ణ సంఖ్య.

394
00:19:47,270 --> 00:19:50,040
ఏ డేటా రకం ఉంది
సి negative_int అని.

395
00:19:50,040 --> 00:19:52,880
ఇది కేవలం Int, కాబట్టి అది జరగబోతోంది
ఖచ్చితంగా చేయడానికి మాకు ఉండాల్సిందే

396
00:19:52,880 --> 00:19:55,340
నిజానికి ఆ విలువ
రిటర్న్డ్ మాత్రమే ఒక పూర్ణాంకానికి ఉంది

397
00:19:55,340 --> 00:19:56,380
కానీ కూడా ప్రతికూలంగా ఉంటుంది.

398
00:19:56,380 --> 00:20:02,150
>> లైన్ 12 న, నేను ఒక వేరియబుల్ ప్రకటించారు చేస్తున్నాను
n మరియు రకం Int చేరుకొని అని.

399
00:20:02,150 --> 00:20:07,500
ఆపై 18 ద్వారా లైన్ 13 లో నేను రెడీ
ఏదో చేస్తూ ఏదో నిజం.

400
00:20:07,500 --> 00:20:11,040
నేను ముందుకు ముద్రణ వెళుతున్న
N, కొలన్ మరియు తరువాత ఒక స్పేస్,

401
00:20:11,040 --> 00:20:12,800
వినియోగదారు కోసం ఒక ప్రాంప్ట్ వంటి.

402
00:20:12,800 --> 00:20:16,410
>> నేను అప్పుడు get_int కాల్ చేస్తున్నాను మరియు
దాని పిలవబడే తిరిగి విలువ నిల్వ

403
00:20:16,410 --> 00:20:18,130
ఆ వేరియబుల్ n లో.

404
00:20:18,130 --> 00:20:22,600
కానీ నేను చేస్తున్న ఉంచడానికి వెళుతున్న
ఈ సమయంలో N 0 కన్నా ఎక్కువ.

405
00:20:22,600 --> 00:20:27,960
ఇతర మాటలలో, యూజర్ నాకు ఒక ఇస్తుంది
Int మరియు ఆ సంఖ్యను 0 కంటే ఎక్కువ,

406
00:20:27,960 --> 00:20:31,180
అప్పుడు, సానుకూల, నేను వెళుతున్న
కేవలం యూజర్ reprompting ఉంచేందుకు,

407
00:20:31,180 --> 00:20:37,160
వాటిని బలవంతంగా ద్వారా, reprompting ఉంచడానికి
సహకరించాలని నాకు ప్రతికూల పూర్ణాంకానికి ఇవ్వండి.

408
00:20:37,160 --> 00:20:41,640
>> మరియు ఒకసారి n నిజానికి negative-- ఉంది
వినియోగదారు ఉన్నప్పుడు చివరకు రకాల -50 అనుకుందాం,

409
00:20:41,640 --> 00:20:46,710
అప్పుడు ఈ సమయంలో లూప్ ఇకపై నిజం
-50 0 కంటే ఎక్కువ కాదు ఎందుకంటే.

410
00:20:46,710 --> 00:20:51,140
కాబట్టి మేము ఆ బయటకు
లూప్ తార్కికంగా మరియు n తిరిగి.

411
00:20:51,140 --> 00:20:53,520
>> కానీ ఇతర ఒక ఉంది
విషయం నేను చేయాల్సిందల్లా.

412
00:20:53,520 --> 00:20:56,190
మరియు నేను కేవలం ఈ చేయవచ్చు
కాపీ మరియు పేస్ట్ ద్వారా

413
00:20:56,190 --> 00:20:58,540
ఫైలు ఎగువన కోడ్ ఒకటి లైన్.

414
00:20:58,540 --> 00:21:01,630
నేను గణగణమని ద్వని చేయు బోధించడానికి అవసరం,
లేదా గణగణమని ద్వని చేయు వాగ్దానం

415
00:21:01,630 --> 00:21:04,630
నడిపేవారిని నేను రెడీ ఆ,
నిజానికి, వెళ్ళి అమలు

416
00:21:04,630 --> 00:21:06,020
ఈ ఫంక్షన్ get_negative_int.

417
00:21:06,020 --> 00:21:07,674
ఇది కేవలం ఫైల్ లో తక్కువ కావచ్చు.

418
00:21:07,674 --> 00:21:09,840
మళ్ళీ, ఆ గుర్తు గణగణమని ద్వని చేయు
పైనుంచి విషయాలు చదివి,

419
00:21:09,840 --> 00:21:12,330
ఎడమ నుండి కుడికి, కాబట్టి మీరు కాదు
గణగణమని ద్వని చేయు ఉంటే ఒక ఫంక్షన్ కాల్

420
00:21:12,330 --> 00:21:15,330
అది ఉనికిలో జరగబోతోంది తెలియదు.

421
00:21:15,330 --> 00:21:18,430
>> ఇప్పుడు, దురదృష్టవశాత్తు, ఈ కార్యక్రమం,
మీరు కొన్ని గమనించి ఉండవచ్చు

422
00:21:18,430 --> 00:21:19,590
ఇప్పటికే బగ్గీ ఉంది.

423
00:21:19,590 --> 00:21:21,400
నాకు ముందుకు వెళ్లి buggy3 తయారు చేద్దాము.

424
00:21:21,400 --> 00:21:26,904
నా సమస్య ఇప్పుడు కాదు, కాబట్టి ఇది కూర్చింది
వాక్యనిర్మాణ దోషం, ఒక పాఠ్య లోపం,

425
00:21:26,904 --> 00:21:29,570
ఇది నిజానికి ఒక తార్కిక చేస్తాడు
నేను ఉద్దేశపూర్వకంగా చేసిన లోపం

426
00:21:29,570 --> 00:21:32,450
అవకాశంగా తయారు
ఏం జరగబోతోంది ద్వారా అడుగు.

427
00:21:32,450 --> 00:21:35,540
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న
ఇప్పుడు, Buggy3 అమలు.

428
00:21:35,540 --> 00:21:37,490
నేను వెళ్ళి వెళుతున్న
ముందుకు మరియు సహకరించాయి.

429
00:21:37,490 --> 00:21:39,494
నేను సంఖ్య 1 ఇవ్వాలని వెళుతున్న.

430
00:21:39,494 --> 00:21:41,410
ఇది ఇష్టం లేదు కనుక
అది నాకు మళ్ళీ ప్రాంప్ట్ యొక్క.

431
00:21:41,410 --> 00:21:42,147
>> ఎలా 2?

432
00:21:42,147 --> 00:21:43,021
3?

433
00:21:43,021 --> 00:21:43,520
50?

434
00:21:43,520 --> 00:21:44,740
ఆ ఒక్కటి పనిచేస్తున్నారు.

435
00:21:44,740 --> 00:21:46,890
ఎలా -50 గురించి?

436
00:21:46,890 --> 00:21:48,560
మరియు కార్యక్రమం పని ఉంది.

437
00:21:48,560 --> 00:21:49,970
>> మరోసారి నాకు ఇది ప్రయత్నించండి లెట్.

438
00:21:49,970 --> 00:21:53,400
నాకు -1 ప్రయత్నించండి లెట్, పని ఉంది.

439
00:21:53,400 --> 00:21:56,380
నాకు -2 ప్రయత్నించండి లెట్, పని ఉంది.

440
00:21:56,380 --> 00:21:59,640
నాకు ప్రయత్నించండి 0 లెట్.

441
00:21:59,640 --> 00:22:01,684
అహ్, ఆ తప్పు.

442
00:22:01,684 --> 00:22:03,350
ఇప్పుడు, మేము ఇక్కడ ఒక చిన్న పాండిత్య ప్రకర్ష ఉండటం చేస్తున్నాం.

443
00:22:03,350 --> 00:22:07,090
కానీ నిజానికి, వార్తలు, కేసు ఆ 0
అనుకూల లేదా ప్రతికూల కాదు.

444
00:22:07,090 --> 00:22:11,150
అందువలన నిజానికి నా కార్యక్రమం
, 0 ప్రతికూల పూర్ణాంక అని అంటున్నారు

445
00:22:11,150 --> 00:22:12,820
సాంకేతికంగా సరైన కాదు.

446
00:22:12,820 --> 00:22:15,180
>> ఇప్పుడు, ఎందుకు ఈ చేస్తోంది?

447
00:22:15,180 --> 00:22:16,270
బాగా, అది స్పష్టమైన కావచ్చు.

448
00:22:16,270 --> 00:22:18,110
మరియు, నిజానికి, కార్యక్రమం
నిరాడంబర అని అర్థం

449
00:22:18,110 --> 00:22:19,670
కాబట్టి మేము అన్వేషించడానికి ఏదైనా కలిగి.

450
00:22:19,670 --> 00:22:25,870
>> కానీ యొక్క మూడవ డీబగ్గింగ్ పరిచయం తెలియజేయండి
టెక్నిక్ ఇక్కడ debug50 అని.

451
00:22:25,870 --> 00:22:27,750
కాబట్టి ఈ ప్రోగ్రామ్ ఉంది
మేము కేవలం సృష్టించిన

452
00:22:27,750 --> 00:22:30,770
ఈ అంటారు సంవత్సరం debug50
మీరు అనుమతిస్తుంది

453
00:22:30,770 --> 00:22:34,130
ఒక అంతర్నిర్మిత అని ఏమి ఉపయోగించడానికి
CS50 IDE లో గ్రాఫికల్ డీబగ్గర్.

454
00:22:34,130 --> 00:22:38,400
మరియు ఒక డీబగ్గర్ కేవలం ఒక కార్యక్రమం అని
సాధారణంగా మీరు మీ కార్యక్రమాన్ని అమలు చేయనిస్తుంది

455
00:22:38,400 --> 00:22:44,050
కానీ దశ, లైన్ బై స్టెప్ బై స్టెప్
లైన్ ద్వారా లైన్ ద్వారా, విరామం చేసే poking

456
00:22:44,050 --> 00:22:47,626
చుట్టూ వేరియబుల్స్ చూడటం కాబట్టి
కార్యక్రమం కేవలం మీరు గత చెదరగొట్టి లేదు

457
00:22:47,626 --> 00:22:49,750
మరియు త్వరగా ఏదో ప్రింట్
లేదా ఏదో ప్రింట్ లేదు.

458
00:22:49,750 --> 00:22:53,250
ఇది, మీరు ఒక అవకాశం ఇస్తుంది
మానవ వేగం, ఇది సంకర్షణ.

459
00:22:53,250 --> 00:22:55,470
>> మరియు దీన్ని మీరు
కేవలం క్రింది వాటిని.

460
00:22:55,470 --> 00:22:58,479
మీ కోడ్ కంపైల్ తరువాత,
ఇది నేను ఇప్పటికే చేశాడు, buggy3,

461
00:22:58,479 --> 00:23:00,020
మీరు ముందుకు వెళ్లి debug50 ./buggy అమలు.

462
00:23:00,020 --> 00:23:03,460

463
00:23:03,460 --> 00:23:06,760
ఎంతగా help50 మీరు అమలు ఉన్నట్లు
help50 ఆపై ఆదేశం,

464
00:23:06,760 --> 00:23:10,120
debug50 మీరు debug50 అమలు మరియు
ఆదేశ పేరు.

465
00:23:10,120 --> 00:23:14,440
>> ఇప్పుడు నా తెరపై ఏమి జరుగుతుందో చూడటానికి,
ముఖ్యంగా కుడి చేతి వైపు.

466
00:23:14,440 --> 00:23:19,400
నేను రన్, అన్ని కొట్టాడు
ఆకస్మిక ఈ కుడి చేతి ప్యానెల్

467
00:23:19,400 --> 00:23:20,419
తెరపై తెరుచుకోవడంతో.

468
00:23:20,419 --> 00:23:22,210
మరియు వెళుతున్న చాలా ఉంది
మొదటి చూపులో న.

469
00:23:22,210 --> 00:23:25,110
కానీ అక్కడ చాలా కాదు
ఇంకా గురించి ఆందోళన ఎక్కువ.

470
00:23:25,110 --> 00:23:28,570
>> ఈ నాకు ప్రతిదీ చూపిస్తూ
నా ప్రోగ్రామ్ యొక్క లోపల ఏం జరగబోతోంది

471
00:23:28,570 --> 00:23:31,130
ప్రస్తుతం ఈ ద్వారా
బటన్లు టాప్ అప్పుడు అప్

472
00:23:31,130 --> 00:23:35,910
నా కోడ్ను ద్వారా దశను అనుమతిస్తుంది
చివరికి స్టెప్ బై స్టెప్ బై స్టెప్.

473
00:23:35,910 --> 00:23:37,140
కానీ ఇంకా లేదు.

474
00:23:37,140 --> 00:23:38,060
ఏమి గమనించండి.

475
00:23:38,060 --> 00:23:40,600
నా టెర్మినల్ విండో వద్ద
నేను n కోసం ప్రాంప్ట్ అయామ్.

476
00:23:40,600 --> 00:23:44,560
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
-1 ఈసారి మరియు రకం సహకరించాయి.

477
00:23:44,560 --> 00:23:48,770
మరియు అయితే కొద్దిగా నిగూఢమైన, -1
అనుకున్న, ఒక ప్రతికూల పూర్ణాంక ఉంది.

478
00:23:48,770 --> 00:23:52,020
>> ఆపై పిల్లల తో నిష్క్రమించారు
స్థితి 0 gdbserver నిష్క్రమించే.

479
00:23:52,020 --> 00:23:55,180
GDB గ్నూ డీబగ్గర్ పేరు
అంతర్లీన సాఫ్ట్వేర్

480
00:23:55,180 --> 00:23:56,620
ఈ డీబగ్గర్ అమలు.

481
00:23:56,620 --> 00:24:00,500
కానీ అన్ని ఈ నిజంగా అర్థం, డీబగ్గర్
నా ప్రోగ్రామ్ విడిచి ఎందుకంటే దూరంగా వెళ్ళాడు

482
00:24:00,500 --> 00:24:01,710
మరియు అన్ని బాగా ఉంది.

483
00:24:01,710 --> 00:24:06,020
నేను నిజంగా నా ప్రోగ్రామ్ డీబగ్ చేయాలనుకుంటే,
నేను preemptively debug50 చెప్పడానికి కలిగి,

484
00:24:06,020 --> 00:24:08,920
నేను ఎక్కడ మొదలు అనుకుంటున్నారు
నా కోడ్ ద్వారా పునాది?

485
00:24:08,920 --> 00:24:11,750
>> మరియు బహుశా సరళమైన మార్గం
ఈ కింది విధంగా ఉంది ఏమి.

486
00:24:11,750 --> 00:24:15,300
నేను హోవర్ ఉంటే
ఇక్కడ నా ఎడిటర్ గట్టర్,

487
00:24:15,300 --> 00:24:19,090
కాబట్టి నిజంగా కేవలం సైడ్బార్లో ఇక్కడ,
లైన్ నెంబర్ ఎడమ

488
00:24:19,090 --> 00:24:21,870
గమనించవచ్చు నేను క్లిక్ చేస్తే ఆ
ఒకసారి నేను కొద్దిగా ఎరుపు బిందువు చాలు.

489
00:24:21,870 --> 00:24:24,460
మరియు ఆ చిన్న ఎరుపు బిందువు,
ఒక స్టాప్ సైన్ వంటి, హే,

490
00:24:24,460 --> 00:24:29,430
debug50, నా కోడ్ విరామం అమలు
అక్కడే నేను ఈ ప్రోగ్రామ్ రన్.

491
00:24:29,430 --> 00:24:30,260
>> కాబట్టి యొక్క ఆ తెలియజేసేలా.

492
00:24:30,260 --> 00:24:37,340
నాకు ముందుకు వెళ్లి నా ప్రోగ్రామ్ రన్
మళ్ళీ debug50 ./buggy3 తో నమోదు చేయండి.

493
00:24:37,340 --> 00:24:40,110
మరియు ఇప్పుడు, నోటీసు, ఏదో
వివిధ జరిగింది.

494
00:24:40,110 --> 00:24:42,440
నేను అడుగకుండా కాదు
ఇంకా నా టెర్మినల్ విండో లో

495
00:24:42,440 --> 00:24:45,430
ఏదైనా, నేను ఎందుకంటే
నా కార్యక్రమంలో ఇంకా అక్కడ సంపాదించిన.

496
00:24:45,430 --> 00:24:47,950
పంక్తి 8 న గమనించవచ్చు
ఇప్పుడు హైలైట్ ఇది

497
00:24:47,950 --> 00:24:51,720
మరియు ఒక చిన్న బాణం ఉంది
ఎడమ నానుడి, మీరు ఇక్కడ పాజ్ ఉంటాయి.

498
00:24:51,720 --> 00:24:55,030
కోడ్, లైన్ యొక్క ఈ లైన్
8, ఇంకా అమలు కాలేదు.

499
00:24:55,030 --> 00:24:58,940
>> మరియు నేను చూస్తే, ఆసక్తికరమైన
కుడి వైపు ఇక్కడ పైగా,

500
00:24:58,940 --> 00:25:03,530
నేను ఒక స్థానిక ఉంది అని గుర్తించలేకపోతే
వేరియబుల్, భావంలో స్థానిక

501
00:25:03,530 --> 00:25:05,450
అది ప్రస్తుత ఫంక్షన్ లోపల.

502
00:25:05,450 --> 00:25:08,920
మరియు దాని విలువ, స్పష్టంగా అప్రమేయంగా,
మరియు సౌకర్యవంతంగా విధమైన, 0 ఉంది.

503
00:25:08,920 --> 00:25:10,260
కానీ నేను టైప్ 0 లేదు.

504
00:25:10,260 --> 00:25:13,410
కేవలం నిర్మాణము దాని
క్షణం వద్ద డిఫాల్ట్ విలువ.

505
00:25:13,410 --> 00:25:15,490
>> నాలో ముందుకు వెళ్లి ఇప్పుడు దీన్ని చూద్దాం.

506
00:25:15,490 --> 00:25:18,680
నాకు ముందుకు వెళ్లి వెళ్ళి తెలపండి
ఇక్కడే ఎగువన, నేను ఉన్నాను

507
00:25:18,680 --> 00:25:20,970
ముందుకు వెళ్లి
ఈ మొదటి చిహ్నాన్ని క్లిక్ ఇది

508
00:25:20,970 --> 00:25:25,360
ఇది స్టెప్ ఓవర్ అర్థం skip లేదు అంటే
అది కాని కోడ్ యొక్క ఈ లైన్ అతిక్రమించి,

509
00:25:25,360 --> 00:25:27,770
మార్గం వెంట అది అమలు.

510
00:25:27,770 --> 00:25:30,710
>> మరియు ఇప్పుడు నోటీసు, నా
ప్రాంప్ట్ కేవలం మార్చబడింది.

511
00:25:30,710 --> 00:25:31,380
ఎందుకు అని?

512
00:25:31,380 --> 00:25:33,639
నేను debug50 చెప్పారు చేసిన,
కోడ్ యొక్క ఈ లైన్ అమలు.

513
00:25:33,639 --> 00:25:34,930
కోడ్ యొక్క ఈ లైన్ ఏమి చేస్తుంది?

514
00:25:34,930 --> 00:25:35,960
ఒక Int కోసం నాకు ప్రాంప్ట్ వస్తుంది.

515
00:25:35,960 --> 00:25:36,460
అలాగే.

516
00:25:36,460 --> 00:25:37,400
నాకు సహకరించిన లెట్.

517
00:25:37,400 --> 00:25:41,340
నాకు ఇప్పుడు ముందుకు వెళ్లి టైప్ -1 ఎంటర్ లెట్.

518
00:25:41,340 --> 00:25:42,920
ఇప్పుడు మార్చబడింది గమనిస్తారు.

519
00:25:42,920 --> 00:25:46,060
కుడి వైపు,
నా స్థానిక వేరియబుల్ నేను

520
00:25:46,060 --> 00:25:48,200
ఉండటం -1 ఇప్పుడు తెలిసింది.

521
00:25:48,200 --> 00:25:49,810
మరియు అది రకం Int ఇప్పటికీ.

522
00:25:49,810 --> 00:25:53,102
>> మరియు నోటీసు, చాలా, నా పిలవబడే
స్టాక్ కాల్, నేను ఎక్కడ విరామం వచ్చింది?

523
00:25:53,102 --> 00:25:54,810
మనం గురించి మరింత మాట్లాడదాము
భవిష్యత్తులో ఈ.

524
00:25:54,810 --> 00:25:58,620
అయితే కాల్ స్టాక్ కేవలం సూచిస్తుంది ఏమి
విధులు ప్రస్తుతం కదలికలో.

525
00:25:58,620 --> 00:26:00,040
ప్రస్తుతం ఇది ప్రధాన వార్తలు.

526
00:26:00,040 --> 00:26:03,590
మరియు ప్రస్తుతం కేవలం స్థానిక
వేరియబుల్ 1 విలువతో i ఉంది.

527
00:26:03,590 --> 00:26:09,840
>> నేను చివరకు ఈ అతిక్రమించి ఉన్నప్పుడు
ఇక్కడ, కుడి ఎగువ అదే చిహ్నం,

528
00:26:09,840 --> 00:26:11,410
-1 ప్రతికూల పూర్ణ సంఖ్య.

529
00:26:11,410 --> 00:26:13,580
ఇప్పుడు అది వంకర కలుపు పైగా విరామం చేసే లో.

530
00:26:13,580 --> 00:26:14,740
యొక్క దాని పనిని లెట్.

531
00:26:14,740 --> 00:26:17,300
నేను ఆ లైన్, మరియు voila అతిక్రమించి.

532
00:26:17,300 --> 00:26:20,240
>> ఐతే అన్ని భయంకరమైన
ప్రకాశాన్ని ఇంకా,

533
00:26:20,240 --> 00:26:23,550
కానీ అది నాకు విరామం వీలు
మరియు తార్కికంగా ఆలోచించడం

534
00:26:23,550 --> 00:26:24,870
ఈ కార్యక్రమం ఏమి చేస్తోంది.

535
00:26:24,870 --> 00:26:26,890
కానీ ఆ తప్పుడు కేసు కాదు.

536
00:26:26,890 --> 00:26:28,510
ఈ క్రింది విధంగా మళ్ళీ తెలియజేసేలా.

537
00:26:28,510 --> 00:26:31,340
>> నేను ఆ బ్రేక్పాయింట్ వదిలి వెళుతున్న
ఎరుపు బిందువు లైన్ 8 న.

538
00:26:31,340 --> 00:26:32,830
నేను debug50 తిరిగి వెళుతున్న.

539
00:26:32,830 --> 00:26:34,400
ఇది స్వయంచాలకంగా ఇక్కడ పాజ్ లో.

540
00:26:34,400 --> 00:26:37,660
కానీ ఈ సమయంలో, బదులుగా
ఈ లైన్ పైన అడుగు పెట్టటం,

541
00:26:37,660 --> 00:26:42,290
నాకు నిజంగా లోపలి వీలు
get_negative_int మరియు బయటకు దొరుకుతుందని,

542
00:26:42,290 --> 00:26:45,530
ఎందుకు అది చెల్లని సమాధానం గా 0 అంగీకరించడం?

543
00:26:45,530 --> 00:26:47,990
>> కాబట్టి దశ ఓవర్ చేయడం బదులుగా.

544
00:26:47,990 --> 00:26:50,630
నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు క్లిక్ లోకి అడుగు.

545
00:26:50,630 --> 00:26:54,030
మరియు పంక్తి 8 అని గమనించవచ్చు
ఇప్పుడు హఠాత్తుగా ఇప్పుడు హైలైట్

546
00:26:54,030 --> 00:26:56,900
లైన్ 17 అవుతుంది.

547
00:26:56,900 --> 00:26:59,947
>> ఇప్పుడు, డీబగ్గర్ అని కాదు
పంక్తులు 14 మరియు 15 మరియు 16 దిగింది చేసింది.

548
00:26:59,947 --> 00:27:01,780
ఇది కేవలం ఏమీ ఉంది లో
అక్కడ మీరు చూపించడానికి.

549
00:27:01,780 --> 00:27:04,050
ఆ వేరియబుల్స్ ప్రకటించుకున్నారు,
ఆపై పదం చేయదగినవి

550
00:27:04,050 --> 00:27:05,390
ఆపై ఒక బహిరంగ వంకర కలుపు.

551
00:27:05,390 --> 00:27:09,227
అని మాత్రమే ఫంక్షనల్ లైన్
జూసీ నిజంగా ఇక్కడ ఈ ఒక, 17 ఉంది.

552
00:27:09,227 --> 00:27:11,060
మేము చేసిన మరియు ఆ
స్వయంచాలకంగా పాజ్.

553
00:27:11,060 --> 00:27:13,870
>> కాబట్టి printf ( "n.is:") ;, కాబట్టి
ఇంకా సంభవించదని.

554
00:27:13,870 --> 00:27:18,250
కాబట్టి యొక్క ముందుకు వెళ్లి అతిక్రమించి క్లిక్ చేయండి.

555
00:27:18,250 --> 00:27:20,326
ఇప్పుడు నా ప్రాంప్ట్, నిజానికి,
మార్చబడింది ( "n- ఉంది:").

556
00:27:20,326 --> 00:27:22,450
ఇప్పుడు నేను వెళుతున్న కాదు, get_int
పునాది ఇబ్బంది,

557
00:27:22,450 --> 00:27:24,750
ఆ ఫంక్షన్ ఎందుకంటే
లైబ్రరీ లో CS50 చేసిన.

558
00:27:24,750 --> 00:27:25,750
ఇది బహుశా సరైన అని.

559
00:27:25,750 --> 00:27:28,440
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
విధమైన ఇవ్వడం ద్వారా సహకరించిన

560
00:27:28,440 --> 00:27:30,590
ఒక Int, కానీ ఒక ప్రతికూల Int.

561
00:27:30,590 --> 00:27:32,870
నాలో ముందుకు వెళ్లి హిట్ 0 వీలు.

562
00:27:32,870 --> 00:27:39,460
ఇప్పుడు ఇక్కడ ఏమి
21 వరుసలో నేను డౌన్ వచ్చినప్పుడు?

563
00:27:39,460 --> 00:27:40,890
నేను మళ్ళీ iterated చెయ్యలేదు.

564
00:27:40,890 --> 00:27:43,320
నేను ఆ లూప్ లో కష్టం కనిపిస్తుంది లేదు.

565
00:27:43,320 --> 00:27:45,990
ఇతర మాటలలో, ఈ పసుపు
బార్ చుట్టూ కొనసాగించడాన్ని లేదు,

566
00:27:45,990 --> 00:27:47,130
మరియు చుట్టూ, మరియు చుట్టూ.

567
00:27:47,130 --> 00:27:48,340
>> ఇప్పుడు, ఎందుకు అని?

568
00:27:48,340 --> 00:27:49,920
బాగా, n, ఏమి ప్రస్తుతం ఉన్న n ఉంది?

569
00:27:49,920 --> 00:27:53,280
నేను స్థానిక చూడవచ్చు
డీబగర్లో వేరియబుల్స్.

570
00:27:53,280 --> 00:27:53,816
N 0 ఉంది.

571
00:27:53,816 --> 00:27:55,190
అన్ని కుడి, నా పరిస్థితి ఏమిటి?

572
00:27:55,190 --> 00:27:58,700
>> 20-- లైన్ 20, ఉంది,
0 0 కంటే ఎక్కువ.

573
00:27:58,700 --> 00:27:59,500
అది నిజం కాదు.

574
00:27:59,500 --> 00:28:01,020
0 0 కంటే ఎక్కువ కాదు.

575
00:28:01,020 --> 00:28:02,820
కాబట్టి నేను ఈ బయటపడిన.

576
00:28:02,820 --> 00:28:06,370
>> అందువలన ఎందుకు లైన్లో వార్తలు
21, నేను నిజానికి కొనసాగితే,

577
00:28:06,370 --> 00:28:10,370
నేను కూడా, 0 తిరిగి వెళుతున్న
నేను తిరస్కరించారు ఉండాలి అయితే 0

578
00:28:10,370 --> 00:28:12,484
వాస్తవానికి నెగటివ్ గా కాదు.

579
00:28:12,484 --> 00:28:14,650
కాబట్టి ఇప్పుడు, నేను నిజంగా కూడా లేదు
డీబగ్గర్ పట్టించుకోనట్లు.

580
00:28:14,650 --> 00:28:16,900
అది నేను అవసరం లేదు గాట్
జరుగుతుందో మరింత తెలుసు.

581
00:28:16,900 --> 00:28:19,233
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు
కేవలం ప్లే బటన్ క్లిక్ చేయండి,

582
00:28:19,233 --> 00:28:20,240
మరియు ఈ ముగింపు అప్ తెలియజేయండి.

583
00:28:20,240 --> 00:28:23,440
ఇప్పుడు, నేను గ్రహించారు చేసిన నా
బగ్ లైన్ 20 న కానేకాదు.

584
00:28:23,440 --> 00:28:25,160
ఆ నా తార్కిక లోపం.

585
00:28:25,160 --> 00:28:28,100
>> కాబట్టి ఏమి నేను అనుకుంటున్నారు
ఈ మార్చడానికి ఏమి?

586
00:28:28,100 --> 00:28:32,500
సమస్య ఉంటే నేను ఉన్నాను అని కాదు
పట్టుకోవడంలో 0, అది కేవలం ఒక తార్కిక లోపం.

587
00:28:32,500 --> 00:28:35,910
నేను n ఏది అయితే చెప్పగలను
కంటే ఎక్కువ లేదా 0 సమానంగా,

588
00:28:35,910 --> 00:28:38,330
మళ్లీ మళ్లీ వినియోగదారు ప్రాంప్ట్ ఉంచండి.

589
00:28:38,330 --> 00:28:41,050
>> సో, మళ్ళీ, సాధారణ తప్పు, బహుశా
మీరు నాకు చూసింది కూడా స్పష్టంగా

590
00:28:41,050 --> 00:28:42,410
కేవలం కొన్ని నిమిషాల క్రితం వ్రాయండి.

591
00:28:42,410 --> 00:28:44,570
కానీ ఇక్కడ takeaway
డీబగ్ 50 అని,

592
00:28:44,570 --> 00:28:46,850
మరియు డీబగ్గింగ్ తో
సాఫ్ట్వేర్ మరింత సాధారణంగా,

593
00:28:46,850 --> 00:28:51,370
మీరు ఈ కొత్త దొరకలేదు శక్తి కలిగి
, మీ స్వంత కోడ్ నడవడానికి చూడండి

594
00:28:51,370 --> 00:28:55,590
ఆ కుడి చేతి ప్యానెల్ ద్వారా ఏమి
మీ వేరియబుల్స్ విలువలు.

595
00:28:55,590 --> 00:28:57,700
కాబట్టి మీరు తప్పనిసరిగా లేదు
ఏదో ఉపయోగించడానికి కలిగి

596
00:28:57,700 --> 00:29:00,630
వంటి ఆ విలువలను ప్రింట్ eprintf.

597
00:29:00,630 --> 00:29:04,430
మీరు నిజంగా వాటిని చూడగలరు
దృశ్యపరంగా తెరపై.

598
00:29:04,430 --> 00:29:08,920
>> ఇప్పుడు, ఈ దాటి, అది పేర్కొంది ఉపయోగకరమని
వార్తలు మరొక టెక్నిక్ ఉందని

599
00:29:08,920 --> 00:29:09,890
నిజానికి సూపర్ సాధారణ.

600
00:29:09,890 --> 00:29:13,120
మరియు మీరు ఎందుకు ఈ చిన్న ఆశ్చర్యానికి ఉండవచ్చు
ఇక్కడ వ్యక్తి వేదికపై కూర్చొనివుంది.

601
00:29:13,120 --> 00:29:16,490
కనుక సాధారణంగా ఈ పద్ధతిని వార్తలు,
రబ్బరు డక్ డీబగ్గింగ్ అని పిలుస్తారు,

602
00:29:16,490 --> 00:29:18,786
ఇది నిజంగా కేవలం ఒక ఉంది
నిజానికి నిబంధన

603
00:29:18,786 --> 00:29:20,660
తరచుగా ఉన్నప్పుడు ప్రోగ్రామర్లు
కోడ్ వ్రాస్తున్న

604
00:29:20,660 --> 00:29:22,650
వారు అవసరం లేదు ఉన్నాము
ఇతరులతో కలిసి,

605
00:29:22,650 --> 00:29:24,030
లేదా ఒక షేర్డ్ వాతావరణంలో పని.

606
00:29:24,030 --> 00:29:25,050
>> వారు ఇంట్లో విధమైన ఉన్నారు.

607
00:29:25,050 --> 00:29:25,910
బహుశా అది రాత్రి ఆలస్యం.

608
00:29:25,910 --> 00:29:28,190
వారు ఆశించాను
వారి కోడ్ లో కొన్ని బగ్.

609
00:29:28,190 --> 00:29:29,330
మరియు వారు కేవలం అది చూసిన కాదు.

610
00:29:29,330 --> 00:29:30,329
>> మరియు ఏ రూమ్మేట్ ఉంది.

611
00:29:30,329 --> 00:29:31,250
ఏ TF ఉంది.

612
00:29:31,250 --> 00:29:32,680
చుట్టూ CA ఉంది.

613
00:29:32,680 --> 00:29:36,440
వారు వారి షెల్ఫ్ న అన్ని
ఈ చిన్న రబ్బరు డక్కి ఉంది.

614
00:29:36,440 --> 00:29:39,030
>> కాబట్టి రబ్బరు డక్ డీబగ్గింగ్
ఈ ఆహ్వానం

615
00:29:39,030 --> 00:29:42,780
వెర్రి ఏదో అనుకుంటున్నారో
ఈ నిజమైన జీవి వలె

616
00:29:42,780 --> 00:29:46,940
మరియు నిజానికి మీ కోడ్ ద్వారా నడిచి
మాటలతో ఈ జీవం లేని వస్తువు.

617
00:29:46,940 --> 00:29:49,230
కాబట్టి, ఉదాహరణకు, ఉంటే
ఈ నా ఉదాహరణ ఇక్కడ

618
00:29:49,230 --> 00:29:52,470
మరియు ఆ ముందు గుర్తుకు
సమస్య ఈ ఉంది,

619
00:29:52,470 --> 00:29:58,140
నేను కోడ్ యొక్క ఈ మొదటి రేఖ తొలగిస్తే,
మరియు నేను ముందుకు వెళ్లి మళ్లీ బగ్గీ 0 చేస్తాము,

620
00:29:58,140 --> 00:30:01,220
నేను ఈ ఉందని గుర్తు
ఇక్కడ లోపం సందేశాలు.

621
00:30:01,220 --> 00:30:05,997
కాబట్టి ఇక్కడ ఆలోచన, నేను అయితే హాస్యాస్పదంగా
బహిరంగంగా ఈ చేయడం సమయంలో అనుభూతి,

622
00:30:05,997 --> 00:30:06,580
ఆ లోపం ఉంది.

623
00:30:06,580 --> 00:30:10,910
>> సరే, నా సమస్య ఏమిటంటే నేను చేసిన ఉంది
పరిపూర్ణంగా ఒక లైబ్రరీ ఫంక్షన్ ప్రకటించింది.

624
00:30:10,910 --> 00:30:12,610
మరియు ఆ printf లైబ్రరీ ఫంక్షన్ ఉంది.

625
00:30:12,610 --> 00:30:15,290
సరే డిక్లేర్, డిక్లేర్
నమూనాలను నాకు గుర్తుచేస్తుంది.

626
00:30:15,290 --> 00:30:18,930
>> నేను నిజంగా అవసరం అంటే
ముందుగానే కంపైలర్ చెప్పడానికి ఏమి

627
00:30:18,930 --> 00:30:19,980
ఫంక్షన్ ఎలా.

628
00:30:19,980 --> 00:30:20,930
ఒక నిమిషం ఆగు.

629
00:30:20,930 --> 00:30:23,580
నేను ప్రామాణిక io.h. లేదు

630
00:30:23,580 --> 00:30:24,530
చాలా ధన్యవాదాలు.

631
00:30:24,530 --> 00:30:27,330
>> కాబట్టి కేవలం ఈ ప్రక్రియ మీరు of--
నిజానికి ఒక డక్ కలిగి అవసరం లేదు.

632
00:30:27,330 --> 00:30:29,819
కానీ వాకింగ్ ఈ ఆలోచన
మీ స్వంత కోడ్ ద్వారా మీ

633
00:30:29,819 --> 00:30:31,610
కాబట్టి మీరు కూడా వినే
మీ, కాబట్టి మీరు

634
00:30:31,610 --> 00:30:35,620
మీ స్వంత లో లోపాల తెలుసుకోవటం
స్టర్ సాధారణంగా ఆలోచన.

635
00:30:35,620 --> 00:30:38,910
>> మరియు, బహుశా మరింత తార్కికంగా, చాలా
ఒక కానీ ఎక్కువ పాల్గొంటుంది ఎక్కువ

636
00:30:38,910 --> 00:30:44,220
ఉదాహరణకు మనం కేవలం బగ్గీ 3.సి లో చేసాడు,
మీరు ద్వారా మిమ్మల్ని నడిచిన ఉండవచ్చు

637
00:30:44,220 --> 00:30:45,310
వంటి అనుసరిస్తుంది.

638
00:30:45,310 --> 00:30:49,190
కాబట్టి అన్ని కుడి, రబ్బరు
డక్కి, DDB, మీరు రెడీ ఉంటే.

639
00:30:49,190 --> 00:30:52,350
ఇక్కడ మేము నా ప్రధాన ఫంక్షన్ కలిగి,
నేను ప్రతికూల పూర్ణాంకానికి పొందుతారు కాల్ చేస్తున్నాను.

640
00:30:52,350 --> 00:30:54,660
>> నేను తిరిగి విలువ పొందడానికి చేస్తున్నాను.

641
00:30:54,660 --> 00:31:00,410
నేను ఎడమ వైపు దీన్ని నిల్వ చేస్తున్నాను
ఒక వేరియబుల్ లైన్ 8 న నేను అనే.

642
00:31:00,410 --> 00:31:02,380
సరే, కానీ వేచి, ఎలా చేసాడు
ఆ విలువ పొందడానికి?

643
00:31:02,380 --> 00:31:04,130
నాకు లైన్ 12 లో ఫంక్షన్ చూద్దాం.

644
00:31:04,130 --> 00:31:05,760
>> లైన్ 12 లో, మేము ప్రతికూల పూర్ణాంకానికి పొందుతారు కలిగి.

645
00:31:05,760 --> 00:31:08,190
ఏ ఇన్పుట్లను తీసుకోదు,
సరే, ఒక పూర్ణాంకానికి తిరిగి లేదు.

646
00:31:08,190 --> 00:31:10,929
నేను లైన్ 14 ఆ వేరియబుల్ n న ప్రకటిస్తుంది.

647
00:31:10,929 --> 00:31:12,220
ఇది పూర్ణాంకం నిల్వ జరగబోతోంది.

648
00:31:12,220 --> 00:31:13,760
ఆ నేను మీరు ఏమి ఉంది.

649
00:31:13,760 --> 00:31:18,480
>> n మాదిరిగా వీలు అందువలన ఈ క్రింది వాటిని
ఇప్పటికే నాకు చేసిన ఏమి పరిష్కారము నేను దిద్దుబాటు రద్దుచెయ్యి.

650
00:31:18,480 --> 00:31:22,710
కాబట్టి n కంటే ఎక్కువ ఉంది
0, సరే, n ప్రింట్.

651
00:31:22,710 --> 00:31:25,170
ఆపై పూర్ణాంకానికి n లో నిల్వ కాల్.

652
00:31:25,170 --> 00:31:30,160
ఆపై n 0 ఉంటే తనిఖీ,
n not-- అక్కడ ఉంది.

653
00:31:30,160 --> 00:31:31,910
సో, మళ్ళీ, మీరు లేదు
అసలు డక్ అవసరం.

654
00:31:31,910 --> 00:31:35,650
కానీ మీరే ద్వారా వాకింగ్
ఒక మేధో వ్యాయామం మీ కోడ్

655
00:31:35,650 --> 00:31:37,720
తరచుగా మీరు సహాయం చేస్తుంది
ఏం జరగబోతోంది తెలుసుకోవటం,

656
00:31:37,720 --> 00:31:41,170
కేవలం ఏదో చేయడం వ్యతిరేకంగా
ఈ వంటి, తెర ఉంటె,

657
00:31:41,170 --> 00:31:43,720
మరియు మీరే ద్వారా మాట్లాడటం లేదు
నిజాయితీగా కాదు అది

658
00:31:43,720 --> 00:31:46,270
దాదాపు సమర్థవంతమైన పద్ధతిని వంటి.

659
00:31:46,270 --> 00:31:48,620
సో అక్కడ మీరు కలిగి, ఒక
వివిధ పద్ధతులు సంఖ్య

660
00:31:48,620 --> 00:31:52,102
నిజానికి మీ కోడ్ డీబగ్గింగ్ కోసం
మరియు తప్పులను వెతకటం, ఇవన్నీ

661
00:31:52,102 --> 00:31:54,810
మీ సంచిలో టూల్స్ ఉండాలి
మీరు అర్థరాత్రి కాదు ఉన్నాము కాబట్టి,

662
00:31:54,810 --> 00:31:57,660
ముఖ్యంగా, మీరు భోజనాల ఉన్నారని
మందిరాలు, లేదా కార్యాలయం గంటల వద్ద,

663
00:31:57,660 --> 00:32:00,368
మీ తల banging
గోడ, కొన్ని సమస్యను పరిష్కరించడానికి ప్రయత్నిస్తున్న.

664
00:32:00,368 --> 00:32:02,020
సాఫ్ట్వేర్ టూల్స్ ఉన్నాయి అని తెలుసుకోవటం.

665
00:32:02,020 --> 00:32:03,720
రబ్బరు డక్ టూల్స్ ఉన్నాయి.

666
00:32:03,720 --> 00:32:09,630
మరియు యొక్క మొత్తం సిబ్బంది ఉంది
ఒక చేతి అప్పిచ్చు వేచి మద్దతు.

667
00:32:09,630 --> 00:32:13,120
>> కాబట్టి ఇప్పుడు, ఒక సమస్య పదం
సెట్లు, మరియు మేము మీరు ఆశతో ఏమి

668
00:32:13,120 --> 00:32:15,620
వాటిని పొందడానికి, మరియు ఎలా
మన మూల్యాంకనం గురించి వెళ్ళండి.

669
00:32:15,620 --> 00:32:17,680
కోర్సు యొక్క సిలబస్ ప్రకారం,
CS50 యొక్క సమస్య సెట్లు

670
00:32:17,680 --> 00:32:22,320
నాలుగు ప్రాధమిక అక్షాలు విశ్లేషించబడుతుంది కాబట్టి,
పరిధిని మాట్లాడటానికి, కచ్చితత్వం, డిజైన్

671
00:32:22,320 --> 00:32:23,060
మరియు శైలి.

672
00:32:23,060 --> 00:32:25,910
మరియు పరిధిని ఎంత సూచిస్తుంది
ముక్క మీరు ఆఫ్ కరిచింది?

673
00:32:25,910 --> 00:32:28,080
ఎలా మీరు ఒక సమస్య ప్రయత్నించారు?

674
00:32:28,080 --> 00:32:30,110
కృషి ఏ స్థాయిలో
మీరు వ్యక్తం చేశారు?

675
00:32:30,110 --> 00:32:35,750
>> సరి, కార్యక్రమం పని కూడా చేస్తుంది
అది CS50 వివరణ ప్రకారం రావలసిన

676
00:32:35,750 --> 00:32:38,640
మీరు కొన్ని ఇన్పుట్లను అందించినప్పుడు
లేదా కొన్ని ప్రతిఫలాన్ని తిరిగి వస్తున్నారా?

677
00:32:38,640 --> 00:32:41,130
డిజైన్ వాటిలో చాలా ఆత్మాశ్రయ ఉంది.

678
00:32:41,130 --> 00:32:43,360
మరియు అది ఒక విల్ వార్తలు
తెలుసుకోవడానికి పొడవైన పడుతుంది

679
00:32:43,360 --> 00:32:47,220
మరియు నేర్పిన పొడవైన,
ఇప్పటివరకు అది boils గా,

680
00:32:47,220 --> 00:32:49,530
మీ కోడ్ రాసిన ఎలా బాగా ఉంది?

681
00:32:49,530 --> 00:32:52,920
>> ఇది కేవలం సరైన ప్రింట్ ఒక విషయం
ప్రతిఫలాన్ని లేదా కుడి విలువలు తిరిగి.

682
00:32:52,920 --> 00:32:55,400
కానీ మీరు చేయట్లేదు
సమర్ధవంతంగా సాధ్యమైనంత?

683
00:32:55,400 --> 00:32:58,210
మీరు విభజన చేస్తున్నారా
జయించటానికి లేదా బైనరీ

684
00:32:58,210 --> 00:33:01,500
మేము వెంటనే మేము ఆ చూస్తారు వంటి శోధన
రెండు వారాల క్రితం ఫోన్ బుక్ తో?

685
00:33:01,500 --> 00:33:04,670
పరిష్కరించడానికి మంచి మార్గాలు ఉన్నాయి
సమస్య మీరు ప్రస్తుతం ఇక్కడ కంటే?

686
00:33:04,670 --> 00:33:06,380
ఆ మంచి డిజైన్ కోసం ఒక అవకాశం.

687
00:33:06,380 --> 00:33:08,530
>> ఆపై శైలి
అందంగా మీ స్మృతి?

688
00:33:08,530 --> 00:33:12,370
మీరు నేను అందంగా ఉన్నాను గమనిస్తారు
నా కోడ్ ఇండెంటింగ్ గురించి,

689
00:33:12,370 --> 00:33:15,300
మరియు ఖచ్చితంగా నా వేరియబుల్స్ మేకింగ్
సహేతుక పెట్టబడింది. n,

690
00:33:15,300 --> 00:33:19,660
కొంతకాలం ఒక మంచి పేరు
సంఖ్య, ఒక లెక్కింపు పూర్ణాంక కోసం నేను,

691
00:33:19,660 --> 00:33:20,727
ఒక స్ట్రింగ్ కోసం s.

692
00:33:20,727 --> 00:33:22,560
మరియు మేము ఇకపై కలిగి
వేరియబుల్ పేర్లు శైలి.

693
00:33:22,560 --> 00:33:25,500
శైలి ఎంత మంచి
మీ కోడ్ చూడండి లేదు?

694
00:33:25,500 --> 00:33:26,600
మరియు అది ఎలా చదవగలిగే?

695
00:33:26,600 --> 00:33:29,650
>> కాలాంతరంలో మీ TAS
మరియు TFS, కోర్సు లో చేస్తాను

696
00:33:29,650 --> 00:33:31,870
మీకు అందించడానికి
గుణాత్మక అభిప్రాయంతో రకం

697
00:33:31,870 --> 00:33:34,330
మీరు మంచి పొందుటకు కనుక
ఆ వివిధ కోణాలను.

698
00:33:34,330 --> 00:33:37,510
మరియు మేము ఎలా పరంగా
ఈ గొడ్డలి ప్రతి విశ్లేషించడానికి,

699
00:33:37,510 --> 00:33:40,080
ఇది అతికొద్ది సాధారణంగా
మీరు ఆ బకెట్లు, సాధారణంగా,

700
00:33:40,080 --> 00:33:41,680
మీరు చేస్తున్న ఎంతవరకు వేసేందుకై.

701
00:33:41,680 --> 00:33:45,680
మరియు, నిజానికి, మీరు ఒక స్కోరు స్వీకరిస్తే
ఆ axes-- సరి, డిజైన్ ఏ

702
00:33:45,680 --> 00:33:49,659
మరియు శైలి ఆ సంఖ్యను especially--
సాధారణంగా 1 మరియు 5 మధ్య ఉంటుంది.

703
00:33:49,659 --> 00:33:52,450
మరియు, వాచ్యంగా, మీరు పొందుతుంటే
3 ప్రారంభంలో సెమిస్టర్ యొక్క,

704
00:33:52,450 --> 00:33:53,977
ఇది చాలా మంచి విషయం.

705
00:33:53,977 --> 00:33:55,810
ఇది ఇప్పటికీ ఉంది అంటే
అభివృద్ధి కోసం గది,

706
00:33:55,810 --> 00:33:58,490
మీరు కోసం ఆశిస్తున్నాము ఇది
మొదటి సారి ఒక తరగతి తీసుకొని.

707
00:33:58,490 --> 00:34:01,820
సీలింగ్ కొన్ని బిట్ ఆశాజనక ఉంది
ఇది మిమ్మల్ని చేరే ఆశపడు చేస్తున్నారు.

708
00:34:01,820 --> 00:34:03,970
అందువలన 3 యొక్క పొందడానికి
ప్రారంభ రచనల్లో,

709
00:34:03,970 --> 00:34:06,550
లేకపోతే కొన్ని 2 మరియు 4 యొక్క,
ఒక మంచి విషయం, నిజానికి, ఉంది.

710
00:34:06,550 --> 00:34:08,880
ఇది పరిధిలోని లోపల బాగా,
అంచనాలను పరిధిలోనే.

711
00:34:08,880 --> 00:34:11,421
>> మరియు మీ మనస్సు రేసింగ్ ఉంది ఉంటే, వేచి
ఒక నిమిషం, ఐదు నుండి మూడు.

712
00:34:11,421 --> 00:34:12,620
ఆ నిజంగా 10 6 కోల్పోయాడు.

713
00:34:12,620 --> 00:34:13,560
60% ఉంది.

714
00:34:13,560 --> 00:34:14,830
ఒక ఎఫ్ అని నా దేవుడు,

715
00:34:14,830 --> 00:34:15,870
>> ఇది కాదు.

716
00:34:15,870 --> 00:34:17,600
నిజానికి అది కాదు, వార్తలు.

717
00:34:17,600 --> 00:34:22,710
అయితే, దాన్ని మెరుగుపరచడానికి ఒక అవకాశం
సెమిస్టర్ క్రమంలో.

718
00:34:22,710 --> 00:34:25,580
మరియు మీరు కొన్ని పొందుతుంటే
పేదలకు, ఈ అవకాశాన్ని ఉంటాయి

719
00:34:25,580 --> 00:34:29,199
ఆఫీసు గంటల, ప్రయోజనాన్ని
ఖచ్చితంగా విభాగాలు మరియు ఇతర వనరులను కలిగివుంటుంది.

720
00:34:29,199 --> 00:34:32,840
>> ఉత్తమ నిజంగా, ఒక అవకాశం,
మీరు చేసిన ఎంత వరకు గర్వపడాల్సిన

721
00:34:32,840 --> 00:34:34,520
సెమిస్టర్ క్రమంలో వస్తాయి.

722
00:34:34,520 --> 00:34:38,199
కాబట్టి, తెలుసుకుంటారు లేకపోతే, ఏమీ
వేరే మూడు మంచిది.

723
00:34:38,199 --> 00:34:40,179
మరియు కాలానుగుణంగా అభివృద్ధి కోసం గది అనుమతిస్తుంది.

724
00:34:40,179 --> 00:34:43,090
>> ఆ పొడవులు ఎలా
అధిక వాస్తవికంగా మీరు

725
00:34:43,090 --> 00:34:46,745
పొందడానికి మీ సమయం చాలా ఖర్చు కానుంది
పని విషయాలు సరిగ్గా విడదీసి.

726
00:34:46,745 --> 00:34:49,120
కాబట్టి సవ్యత కావాలనుకుంటాడు
తో, చాలా ప్రాధాన్యత

727
00:34:49,120 --> 00:34:51,360
మూడు ఈ గుణకార కారకం.

728
00:34:51,360 --> 00:34:54,659
డిజైన్ కూడా ముఖ్యం, కానీ
మీరు తప్పనిసరిగా చేయలేని ఏదో

729
00:34:54,659 --> 00:34:58,220
ఆ గంటల అన్ని ఖర్చు
విషయాలు కేవలం పని పొందుటకు ప్రయత్నిస్తున్న.

730
00:34:58,220 --> 00:35:00,019
>> మరియు కనుక ఇది బరువు వార్తలు
కొంచెం తేలికగా.

731
00:35:00,019 --> 00:35:01,560
మరియు అప్పుడు శైలి కనీసం ప్రాధాన్యత ఉంది.

732
00:35:01,560 --> 00:35:03,710
కూడా అది తక్కువ అయితే
ప్రాధమికంగా ముఖ్యమైన,

733
00:35:03,710 --> 00:35:05,990
ఇది కేవలం, బహుశా,
కుడి దీన్ని సులువైన విషయం

734
00:35:05,990 --> 00:35:08,440
ఉదాహరణలు మనం అనే
ఉపన్యాసం మరియు విభాగంలో,

735
00:35:08,440 --> 00:35:11,080
చక్కగా విషయాలు
ఇండెంట్ మరియు వ్యాఖ్యానించారు,

736
00:35:11,080 --> 00:35:14,320
మొదలగునవి సులభమయిన ఒకటిగా ఉంది
చేయండి మరియు కుడి పొందుటకు విషయాలు.

737
00:35:14,320 --> 00:35:16,960
కాబట్టి వంటి, తెలుసుకోవటం
ఆ పాయింట్లు ఉన్నాయి

738
00:35:16,960 --> 00:35:19,000
అని గ్రహించి చాలా సులభం.

739
00:35:19,000 --> 00:35:22,360
>> ఇప్పుడు పదంపై
విద్యా నిజాయితీ దీన్ని.

740
00:35:22,360 --> 00:35:25,150
కాబట్టి కోర్సు యొక్క శాతం
సిలబస్, మీరు చూస్తారు

741
00:35:25,150 --> 00:35:27,630
కోర్సు కూడా ఉంది అని చాలా
ఈ చుట్టూ భాష యొక్క బిట్.

742
00:35:27,630 --> 00:35:31,380
అంతే కాకుండా సమస్యను తీసుకుని
చాలా తీవ్రంగా విద్యా నిజాయితీ.

743
00:35:31,380 --> 00:35:33,450
>> మేము వ్యత్యాసం కలిగి,
మంచి కోసం లేదా చెడుకో,

744
00:35:33,450 --> 00:35:36,570
ఆఫ్ పంపిన కలిగి ప్రతి సంవత్సరం
క్రమశిక్షణా చర్య విద్యార్థులను

745
00:35:36,570 --> 00:35:39,670
అత్యంత ఏదైనా ఇతర కంటే
కోర్సు యొక్క, నేను తెలుసు అని.

746
00:35:39,670 --> 00:35:42,580
ఇది అవసరమైన కాదు
నిజానికి చిహ్నం

747
00:35:42,580 --> 00:35:46,340
ఆ CS విద్యార్థులు, లేదా CS50 విద్యార్థులు, ఉన్నాయి
ఏ తక్కువ మీ తోటి విద్యార్థుల కంటే నిజాయితీ.

748
00:35:46,340 --> 00:35:49,090
కానీ వాస్తవంలో ఆ ఈ
ప్రపంచ, ఎలక్ట్రానిక్, మేము కేవలం

749
00:35:49,090 --> 00:35:50,990
సాంకేతిక కలిగి
ఈ గుర్తించే అర్థం.

750
00:35:50,990 --> 00:35:53,360
>> దాని కోసం మాకు ముఖ్యం
తరగతి అంతటా న్యాయంగా

751
00:35:53,360 --> 00:35:58,550
ఈ కనుగొనాలి మరియు పెంచడానికి మనం చేసే
సమస్య మేము విషయాలు చూసినప్పుడు.

752
00:35:58,550 --> 00:36:01,980
మరియు కేవలం ఒక చిత్రాన్ని చిత్రించడానికి, మరియు నిజంగా
ఈ సింక్ వంటి ఏదో సహాయం,

753
00:36:01,980 --> 00:36:04,600
వీటిలో సంఖ్యలు
గత 10 సంవత్సరాలుగా విద్యార్థులు

754
00:36:04,600 --> 00:36:07,610
కొన్ని ప్రమేయం చేసిన
విద్యా నిజాయితీ అటువంటి సమస్యలు,

755
00:36:07,610 --> 00:36:10,990
కొన్ని 32 మంది విద్యార్ధులతో
పతనం 2015, నుండి

756
00:36:10,990 --> 00:36:13,760
మేము పడుతుంది లేదు అని చెప్పబడినది
విషయం చాలా తీవ్రంగా.

757
00:36:13,760 --> 00:36:18,380
మరియు, చివరికి, ఈ సంఖ్యలు కంపోజ్,
ఇటీవల సుమారు 3%, 4% లేదా

758
00:36:18,380 --> 00:36:19,120
తరగతి.

759
00:36:19,120 --> 00:36:25,220
>> కాబట్టి విద్యార్థులు సూపర్ మెజారిటీ కోసం
ఇది పంక్తులు స్పష్టంగా తెలుస్తుంది.

760
00:36:25,220 --> 00:36:27,940
కానీ ఈ వస్తున్నాను
మనస్సు, ముఖ్యంగా చివరి

761
00:36:27,940 --> 00:36:32,080
పోరాడుతున్న రాత్రి
సమస్య సెట్ కొన్ని పరిష్కారం,

762
00:36:32,080 --> 00:36:34,830
విధానాల ఉన్నాయి
మీరే పొందడానికి

763
00:36:34,830 --> 00:36:37,870
మీరు కంటే మద్దతు ఉండవచ్చు
కూడా ఆ గంట వద్ద, నేను భావిస్తున్నాను.

764
00:36:37,870 --> 00:36:40,514
మనం అందుకున్నప్పుడు రియలైజ్
విద్యార్ధి సమర్పణలు మనం అడ్డగించి

765
00:36:40,514 --> 00:36:43,430
ఈ సంవత్సరం ప్రతి సమర్పణ సరిపోల్చండి
ప్రతి సమర్పణ గత ఏడాది,

766
00:36:43,430 --> 00:36:47,590
2007 నుండి ప్రతి సమర్పణ వ్యతిరేకంగా,
మరియు అలాగే, చూడటం, నుండి,

767
00:36:47,590 --> 00:36:49,931
కోడ్ నిక్షేప ఆన్లైన్,
చర్చావేదికలు, ఉద్యోగ ప్రదేశాలు.

768
00:36:49,931 --> 00:36:51,806
మరియు మేము ఈ మైల్,
నిజంగా, మాట కోసం అన్ని

769
00:36:51,806 --> 00:36:56,040
పూర్తి బహిర్గతం యొక్క, ఆ ఉంటే
ఎవరో ఆన్లైన్ కనుగొంటారు,

770
00:36:56,040 --> 00:36:57,880
ఖచ్చితంగా, కాబట్టి మేము కోర్సు చేయవచ్చు.

771
00:36:57,880 --> 00:37:00,100
కానీ, నిజంగా, ఆత్మ
కోర్సు డౌన్ దిమ్మల

772
00:37:00,100 --> 00:37:01,650
సిలబస్ లో ఈ నిబంధన ఉంది.

773
00:37:01,650 --> 00:37:03,670
ఇది నిజంగా కేవలం సహేతుకమైన ఉండాలి.

774
00:37:03,670 --> 00:37:06,680
>> మరియు మేము ఉన్నట్లయితే వివరించడానికి
కేవలం ఒక బిట్ మరింత భాషతో,

775
00:37:06,680 --> 00:37:09,770
తెలుసుకుంటారు అన్ని యొక్క సారాంశం
మీరు ఈ కోర్సు సమర్పించే పని

776
00:37:09,770 --> 00:37:10,954
మీ సొంత ఉండాలి.

777
00:37:10,954 --> 00:37:13,870
కానీ ఆ లోపల, ఖచ్చితంగా
అవకాశాలు, మరియు ప్రోత్సాహం

778
00:37:13,870 --> 00:37:17,300
తిరగడం మరియు బోధనకు విలువ
నాకు others--, TFS, కాస్,

779
00:37:17,300 --> 00:37:20,760
టాస్, మరియు తరగతి లో ఇతరులు
మద్దతు కోసం, ఒంటరిగా స్నేహితులు

780
00:37:20,760 --> 00:37:23,547
మరియు రూమ్మేట్స్ ఎవరు అధ్యయనం
ముందు CS మరియు ప్రోగ్రామింగ్.

781
00:37:23,547 --> 00:37:25,130
మరియు అందువలన కోసం ఒక భత్యం ఉంది.

782
00:37:25,130 --> 00:37:28,180
మరియు thumb సాధారణ నియమం
సహాయం కోసం దీన్ని అడుగుతూ ఉన్నప్పుడు,

783
00:37:28,180 --> 00:37:31,470
మీరు ఇతరులకు మీ కోడ్ చూపవచ్చు,
కానీ వారి వీక్షించడానికి పోవచ్చు.

784
00:37:31,470 --> 00:37:34,880
కాబట్టి మీరు ఆఫీసు గంటల వద్ద ఉన్నప్పుడు కూడా,
లేదా D హాల్, లేదంటే ఎక్కడో

785
00:37:34,880 --> 00:37:37,450
కొన్ని ముక్క సెట్ పైన పని,
ఒక స్నేహితుడు, కలిసి పని ఇది

786
00:37:37,450 --> 00:37:40,160
వద్ద పూర్తిగా ఉత్తమంగా ఉంటుంది
రోజు మీ పని యొక్క చివరి

787
00:37:40,160 --> 00:37:43,034
చివరికి ప్రతి చెందిన ఉండాలి
మీరు వరుసగా, మరియు

788
00:37:43,034 --> 00:37:45,700
కొన్ని సహకార ప్రయత్నమని,
చివరి ప్రాజెక్ట్ సందర్భం మినహా

789
00:37:45,700 --> 00:37:47,410
అది అనుమతి మరియు ప్రోత్సహించింది లో.

790
00:37:47,410 --> 00:37:49,830
>> మీరు ఉంటే రియలైజ్
ఏదో తో పోరాడుతున్న

791
00:37:49,830 --> 00:37:52,520
మరియు మీ స్నేహితుడు కేవలం జరుగుతుంది
అప్పుడు ఈ వద్ద మంచి మీరు

792
00:37:52,520 --> 00:37:55,130
లేదా మీరు కంటే ఆ సమస్య వద్ద మంచి,
లేదా మీరు కంటే దూరంగా ముందుకు కొద్దిగా,

793
00:37:55,130 --> 00:37:57,330
అది తిరుగులేని పూర్తిగా సహేతుకమైన వార్తలు
మీ స్నేహితుడికి మరియు హే అని,

794
00:37:57,330 --> 00:38:00,480
మీరు ఇక్కడ నా కోడ్ చూడటం పట్టించుకోవడం లేదు,
నాకు నా సమస్య ఏమిటి గుర్తించడం సహాయం?

795
00:38:00,480 --> 00:38:03,760
మరియు, ఆశాజనక, లో
బోధనకు విలువ వడ్డీ

796
00:38:03,760 --> 00:38:07,040
ఆ స్నేహితుడు కేవలం చేస్తుంది
చెప్పేది OH, దీన్ని, కానీ,

797
00:38:07,040 --> 00:38:09,917
ఏమి మీరు లైన్ తప్పిపోయాయి
6, లేదా అలాంటిదే?

798
00:38:09,917 --> 00:38:12,000
కానీ పరిష్కారం కాదు
మీరు పక్కన స్నేహితుడు కోసం

799
00:38:12,000 --> 00:38:15,617
చెప్పటానికి, OH, బాగా, ఇక్కడ, నాకు పుల్ వీలు
ఈ అప్, మరియు మీరు నా పరిష్కారం చూపించు.

800
00:38:15,617 --> 00:38:16,450
కాబట్టి ఆ లైన్.

801
00:38:16,450 --> 00:38:18,670
మీరు మీ కోడ్ చూపించు
ఇతరులు, కానీ మీరు చేయకపోవచ్చు

802
00:38:18,670 --> 00:38:22,350
వారిది వీక్షించడానికి ఇతర లోబడి
కోర్సు యొక్క సిలబస్ లో అడ్డంకులు.

803
00:38:22,350 --> 00:38:24,760
>> సో మనస్సు ఈ ఉంచేందుకు లేదు
విచారం నిబంధన అని పిలవబడే

804
00:38:24,760 --> 00:38:27,560
అలాగే కోర్సు యొక్క సిలబస్ లో,
మీరు కొన్ని చర్య కమిట్ ఉంటే

805
00:38:27,560 --> 00:38:30,476
సమంజసం కాదు, కానీ దానిని తీసుకుని
కోర్సు యొక్క తలలు దృష్టిని

806
00:38:30,476 --> 00:38:34,240
72 గంటల్లో, కోర్సు
స్థానిక ఆంక్షలు విధించే ఉండవచ్చు

807
00:38:34,240 --> 00:38:37,380
ఒక అసంతృప్తికర కలిగి ఉండవచ్చు లేదా
సమర్పించిన పని కోసం విఫలమయ్యాడు గ్రేడ్.

808
00:38:37,380 --> 00:38:41,410
కానీ కోర్సు చూడండి కాదు
మరింత క్రమశిక్షణా చర్య కోసం పట్టింపు,

809
00:38:41,410 --> 00:38:43,010
పునరావృతం చర్యలు సందర్భాలలో తప్ప.

810
00:38:43,010 --> 00:38:46,632
ఇతర మాటలలో, కొన్ని చేయడానికి మీరు లేకపోతే
స్టుపిడ్, ముఖ్యంగా అర్థరాత్రి, నిర్ణయం

811
00:38:46,632 --> 00:38:49,340
ఆ మరుసటి రోజు లేదా రెండు రోజులు
తరువాత, మీరు మేల్కొలపడానికి మరియు గ్రహించడం,

812
00:38:49,340 --> 00:38:50,870
నేను ఏమి ఆలోచిస్తున్నాడు?

813
00:38:50,870 --> 00:38:53,890
మీరు ఒక అవుట్లెట్ కలిగి CS50 లో ఏమి
ఆ సమస్య పరిష్కారానికి

814
00:38:53,890 --> 00:38:57,170
తద్వారా ఇది వరకు సొంతం, మేము
సగం మీరు అనుగుణంగా మరియు వ్యవహరించే

815
00:38:57,170 --> 00:39:01,500
అది ఒక విషయంలో ఆ రెండు ఉంది
విద్యా మరియు మీరు కోసం విలువైన,

816
00:39:01,500 --> 00:39:04,200
కానీ కొన్ని విధంగా ఇప్పటికీ శిక్షాత్మక.

817
00:39:04,200 --> 00:39:08,590
ఇప్పుడు అంచు బయట ఈ తీసుకోవాలని,.

818
00:39:08,590 --> 00:39:10,570
>> [వీడియో ప్లేబ్యాక్]

819
00:39:10,570 --> 00:39:13,540
>> [సంగీతాన్ని]

820
00:39:13,540 --> 00:39:58,090

821
00:39:58,090 --> 00:39:58,866
>> [END ప్లేబ్యాక్]

822
00:39:58,866 --> 00:40:00,490
డేవిడ్ J. మలన్: అన్ని కుడి, మేము తిరిగి ఉంటాయి.

823
00:40:00,490 --> 00:40:03,680
మరియు ఇప్పుడు మేము ఒక చూడండి
మొదటి మా వాస్తవ ప్రపంచంలో డొమెయిన్ల

824
00:40:03,680 --> 00:40:08,720
CS50 లో, గూఢ లిపి శాస్త్రం యొక్క కళ,
పంపడం మరియు స్వీకరించడం కళ

825
00:40:08,720 --> 00:40:11,840
రహస్య సందేశాలు, ఎన్క్రిప్టెడ్
మీరు రెడీ ఉంటే సందేశాలు,

826
00:40:11,840 --> 00:40:17,060
మీరు కలిగి ఉంటే మాత్రమే అవగతం చేసుకోవచ్చు
పంపినవారు ఉంది కొన్ని కీలక అంశం

827
00:40:17,060 --> 00:40:18,030
అలాగే.

828
00:40:18,030 --> 00:40:22,120
మేము తీసుకుంటాము కాబట్టి ఈ చైతన్యపరచటంలో
ఇక్కడ ఈ విషయం చూడండి,

829
00:40:22,120 --> 00:40:26,750
ఇది ఒక ఒక ఉదాహరణ
రహస్య డికోడర్ రింగ్ అని

830
00:40:26,750 --> 00:40:34,042
గుర్తించడానికి క్రమంలో ఉపయోగించవచ్చు
ఒక రహస్య సందేశం నిజంగానే ఏమిటి.

831
00:40:34,042 --> 00:40:35,750
నిజానికి, వెనుక
గ్రేడ్ పాఠశాల లో రోజు,

832
00:40:35,750 --> 00:40:38,787
మీరు ఎప్పుడైనా రహస్య సందేశాలు పంపిన ఉంటే
కొన్ని స్నేహితుడు లేదా తరగతి లో కొన్ని ప్రేమను,

833
00:40:38,787 --> 00:40:40,620
మీరు భావించి ఉంటారు
మీరు తెలివైన పొందారు

834
00:40:40,620 --> 00:40:46,530
కాగితం మారుతున్న మీ భాగాన్ని,
వంటి ఒక B, మరియు B సి, మరియు సి D కు,

835
00:40:46,530 --> 00:40:47,590
మొదలగునవి.

836
00:40:47,590 --> 00:40:50,300
కానీ మీరు నిజంగా ఎన్క్రిప్ట్ చేశారు
మీ సమాచారాన్ని కూడా

837
00:40:50,300 --> 00:40:53,300
అది ఒక చిన్న చిన్నవైన, ఒకవేళ కాదు
గ్రహించడం ఉపాధ్యాయునికి ఆ హార్డు,

838
00:40:53,300 --> 00:40:55,675
బాగా, మీరు మార్చుకుంటే
బి మరియు సి బి,

839
00:40:55,675 --> 00:40:57,550
మీరు నిజంగా దొరుకుతుందని
సందేశం, ఏమిటి

840
00:40:57,550 --> 00:40:59,700
కానీ మీరు సమాచారాన్ని ciphering ఉన్నాయి.

841
00:40:59,700 --> 00:41:03,420
>> మీరు కేవలం చేస్తున్న
కేవలం చాలా ఇక్కడ Ralphie వంటి

842
00:41:03,420 --> 00:41:07,934
పోషించే ఒక ప్రసిద్ధ చిత్రం లో
చాలా చక్కని ప్రకటన nauseum ప్రతి శీతాకాలంలో.

843
00:41:07,934 --> 00:41:08,600
[వీడియో ప్లేబ్యాక్]

844
00:41:08,600 --> 00:41:11,180
ఇది అన్ని ఆ తెలిసిన-ఉండండి
రాల్ఫ్ పార్కర్ దీన్ని ఉంది

845
00:41:11,180 --> 00:41:14,070
లిటిల్ సభ్యునిగా నియమించారు
ఆర్ఫన్ అన్నీ సీక్రెట్ సర్కిల్

846
00:41:14,070 --> 00:41:17,700
మరియు అన్ని గౌరవాలు అర్హత ఉంది
మరియు ప్రయోజనాలు అందుకు సంభవించే.

847
00:41:17,700 --> 00:41:24,340
>> ఒప్పందం కుదుర్చుకున్నాడు, లిటిల్ ఆర్ఫన్ అన్నీ,
కౌంటర్ సంతకం సిరా, పియరీ ఆండ్రీ.

848
00:41:24,340 --> 00:41:27,160
గౌరవాలు మరియు ప్రయోజనాలు
తొమ్మిదేళ్ళ వయసులో ఇప్పటికే.

849
00:41:27,160 --> 00:41:30,490

850
00:41:30,490 --> 00:41:31,825
>> [అరవటం]

851
00:41:31,825 --> 00:41:33,750

852
00:41:33,750 --> 00:41:34,250
పై -Come.

853
00:41:34,250 --> 00:41:35,210
అది తో పొందండి లెట్.

854
00:41:35,210 --> 00:41:39,530
నేను ఆ జాజ్ అవసరం లేదు
రవాణాదారులు మరియు పైరేట్స్ గురించి.

855
00:41:39,530 --> 00:41:41,660
>> రేపు రాత్రి వినండి
ముగింపు సాహస

856
00:41:41,660 --> 00:41:43,880
బ్లాక్ పైరేట్ నౌక.

857
00:41:43,880 --> 00:41:46,650
ఇప్పుడు, అది యొక్క సమయం
అన్నీ యొక్క రహస్య సందేశాన్ని

858
00:41:46,650 --> 00:41:49,840
సీక్రెట్ సర్కిల్ మీరు సభ్యులు.

859
00:41:49,840 --> 00:41:53,570
గుర్తుంచుకో, పిల్లలు, సభ్యులు మాత్రమే
అన్నీ యొక్క సీక్రెట్ సర్కిల్

860
00:41:53,570 --> 00:41:56,140
అన్నీ యొక్క రహస్య సందేశం డీకోడ్ చేయవచ్చు.

861
00:41:56,140 --> 00:42:00,340
>> గుర్తుంచుకోండి, అన్నీ మీరు ఆధారపడి ఉంటుంది.

862
00:42:00,340 --> 00:42:02,880
B2 మీ పిన్స్ సెట్.

863
00:42:02,880 --> 00:42:05,230
ఇక్కడ సందేశం.

864
00:42:05,230 --> 00:42:06,090
12, 11--

865
00:42:06,090 --> 00:42:10,250
>> -I, నా మొదటి రహస్య సమావేశం am.

866
00:42:10,250 --> 00:42:13,890
>> -14, 11, 18, 16.

867
00:42:13,890 --> 00:42:15,780
>> -Pierre గొప్ప వాయిస్ టునైట్ లో.

868
00:42:15,780 --> 00:42:19,000
నేను ఆ రాత్రి యొక్క తెలియజేయగలరా
సందేశం నిజంగా ముఖ్యమైనది.

869
00:42:19,000 --> 00:42:22,694
>> -3, 25, ఒక సందేశం
అన్నీ తనకు నుండి.

870
00:42:22,694 --> 00:42:23,860
గుర్తుంచుకోండి, ఎవరికీ లేదు.

871
00:42:23,860 --> 00:42:28,760

872
00:42:28,760 --> 00:42:32,930
>> -90 సెకన్ల తరువాత, నేను మాత్రమే ఉన్నాను
ఇంట్లో గదిలో ఉన్న తొమ్మిది ఒక బాలుడు

873
00:42:32,930 --> 00:42:37,040
గోప్యతా మరియు డీకోడ్ లో కూర్చుని.

874
00:42:37,040 --> 00:42:39,730
ఆహా, బి!

875
00:42:39,730 --> 00:42:42,360
నేను తరువాత, ఇ వెళ్లిన

876
00:42:42,360 --> 00:42:44,520
>> మొదటి పదం ఉంటుంది ఉంది.

877
00:42:44,520 --> 00:42:49,032
ఎస్, అది ఇప్పుడు సులభంగా దాగి ఉంది, U, 25--

878
00:42:49,032 --> 00:42:51,733
>> -ఓహ్, Ralphie వస్తాయి, నేను వెళ్ళి చూడాలి!

879
00:42:51,733 --> 00:42:53,688
>> కుడి డౌన్ -I'll, మా!

880
00:42:53,688 --> 00:42:54,188
గీ whiz!

881
00:42:54,188 --> 00:42:58,116

882
00:42:58,116 --> 00:43:04,060
>> -T, ఓ, ఆలోచన ఏమి తప్పకుండా తప్పకుండా?

883
00:43:04,060 --> 00:43:05,970
లిటిల్ ఆర్ఫన్ ఏమిటి
అన్నీ చెప్పటానికి ప్రయత్నిస్తున్న?

884
00:43:05,970 --> 00:43:07,264
ఏమి నిర్ధారించుకోండి?

885
00:43:07,264 --> 00:43:09,634
>> -Ralphie, ఆండీ కలిగియున్నది
వెళ్ళి, మీరు రండి ఉంటుంది?

886
00:43:09,634 --> 00:43:10,480
>> -అన్ని కుడి, మా!

887
00:43:10,480 --> 00:43:12,880
నేను బయట ఉంటాము!

888
00:43:12,880 --> 00:43:14,550
>> -I ఇప్పుడు దగ్గరగా.

889
00:43:14,550 --> 00:43:16,620
ఉద్రిక్తత భయంకరమైన ఉంది.

890
00:43:16,620 --> 00:43:17,720
అదేమిటి?

891
00:43:17,720 --> 00:43:20,170
గ్రహం యొక్క విధి
సంతులనం లో ఆగిపోవచ్చు.

892
00:43:20,170 --> 00:43:20,670
>> -Ralphie!

893
00:43:20,670 --> 00:43:23,170
ఆండీ యొక్క వెళ్ళాలి!

894
00:43:23,170 --> 00:43:26,890
>> బిగ్గరగా ఏడవడం కోసం, కుడి అవుట్ -I'll!

895
00:43:26,890 --> 00:43:32,680
>> అక్కడ -Almost, నా వేళ్ళు వెళ్లింది, నా మనసు
ఉక్కు ఉచ్చు ఉంది, ప్రతి చిన్న రంధ్రము కంపింపజేశాయి.

896
00:43:32,680 --> 00:43:37,198
అవును, అవును, అవును అది దాదాపు స్పష్టమైన ఉంది.

897
00:43:37,198 --> 00:43:43,091
>> మీ Ovaltine త్రాగటానికి ఖచ్చితంగా-ఉండండి.

898
00:43:43,091 --> 00:43:43,590
Ovaltine?

899
00:43:43,590 --> 00:43:48,160

900
00:43:48,160 --> 00:43:49,430
ఒక crummy వాణిజ్య?

901
00:43:49,430 --> 00:43:53,046

902
00:43:53,046 --> 00:43:54,227
ఒక బిచ్ కుమారుడు.

903
00:43:54,227 --> 00:43:54,810
[END ప్లేబ్యాక్]

904
00:43:54,810 --> 00:43:57,390
డేవిడ్ J. మలన్: సరే,
అని ఒక చాలా మార్గం

905
00:43:57,390 --> 00:44:00,660
గూఢ లిపి శాస్త్రం పరిచయం,
మరియు కూడా Ovaltine.

906
00:44:00,660 --> 00:44:04,470
నిజానికి, ఈ పాత ప్రకటన నుండి
ఇక్కడ ప్రశ్న, ఎందుకు Ovaltine కాబట్టి మంచి?

907
00:44:04,470 --> 00:44:09,470
ఇది పక్వత యొక్క దృష్టి సంగ్రహం
బార్లీ, స్వచ్ఛమైన సంపన్న ఆవు పాలు,

908
00:44:09,470 --> 00:44:14,360
మరియు ప్రత్యేకంగా కలిసి, కోకో సిద్ధం
సహజ phosphatides మరియు విటమిన్లు తో.

909
00:44:14,360 --> 00:44:18,240
ఇది మరింత తో బలోపేతం
అదనపు విటమిన్లు B మరియు D, yum.

910
00:44:18,240 --> 00:44:21,600
మీరు ఇప్పటికీ స్పష్టంగా, అది పొందవచ్చు,
అమెజాన్ న, మేము ఇక్కడ వలె.

911
00:44:21,600 --> 00:44:24,810
>> కానీ ప్రేరణ ఇక్కడ ఉంది
ప్రత్యేకంగా, గూఢ పరిచయం

912
00:44:24,810 --> 00:44:28,340
తెలిసిన నిగూఢ రకం
రహస్య కీ గూఢ లిపి శాస్త్రం.

913
00:44:28,340 --> 00:44:34,284
పేరు సూచించినట్లు, మొత్తం
ఒక రహస్య కీని క్రిప్టో వ్యవస్థ భద్రతే

914
00:44:34,284 --> 00:44:36,200
మీరు, ఒక పద్దతి ఉంటే
కేవలం స్క్రాంబ్లింగ్ కోసం

915
00:44:36,200 --> 00:44:40,960
ఇద్దరు వ్యక్తుల మధ్య సమాచారం, అంటే
మాత్రమే పంపినవారు మరియు మాత్రమే గ్రహీత

916
00:44:40,960 --> 00:44:46,980
ఒక రహస్య key-- కొన్ని విలువ తెలుసా, కొన్ని
రహస్య పదబంధాన్ని కొన్ని రహస్య సంఖ్యలో,

917
00:44:46,980 --> 00:44:50,660
వాటిని రెండు గుప్తీకరించడానికి అనుమతిస్తుంది
మరియు వ్యక్తీకరించడానికి సమాచారం.

918
00:44:50,660 --> 00:44:53,470
గూఢ లిపి శాస్త్రం, నిజంగా,
వారం 0 నుండి కేవలం ఈ ఉంది.

919
00:44:53,470 --> 00:44:56,715
>> అది ఇన్పుట్లను ఇక్కడ ఒక సమస్య,
ఇంగ్లీష్ వాస్తవ సందేశం వంటి

920
00:44:56,715 --> 00:44:59,340
లేదా సంసార భాషలో మీరు ఆ
తరగతి లో ఒకరికి పంపాలని,

921
00:44:59,340 --> 00:45:00,580
లేదా ఇంటర్నెట్ అంతటా.

922
00:45:00,580 --> 00:45:03,840
అన్నారు ఇది కొన్ని అవుట్పుట్ ఉంది
గిలకొట్టిన సందేశం మీరు ఆ

923
00:45:03,840 --> 00:45:05,250
గ్రహీత పొందాలనుకుంటున్నారా.

924
00:45:05,250 --> 00:45:07,405
మరియు కూడా లో ఎవరైనా
మధ్య చాలా అందుకునే,

925
00:45:07,405 --> 00:45:09,780
మీరు వాటిని వద్దు
తప్పనిసరిగా దానిని వ్యక్తీకరించడానికి చెయ్యగలరు,

926
00:45:09,780 --> 00:45:12,840
ఈ లోపల ఎందుకంటే
బ్లాక్ బాక్స్, లేదా యాంత్రిక పద్ధతి

927
00:45:12,840 --> 00:45:17,650
కొంత యంత్రాంగం, స్టెప్ ద్వారా కొన్ని అడుగు
ఆ ఇన్పుట్ తీసుకున్నందుకు సూచనలను,

928
00:45:17,650 --> 00:45:20,710
మరియు మార్చే
అవుట్పుట్ ఆశాజనక ఒక సురక్షిత విధంగా.

929
00:45:20,710 --> 00:45:23,640
>> కొన్ని మరియు, నిజానికి, ఉంది
ఈ ప్రపంచంలో పదజాలం అనుసరిస్తుంది.

930
00:45:23,640 --> 00:45:26,100
సాదా టెక్స్ట్ పదం ఉంది
కంప్యూటర్ శాస్త్రవేత్త చేస్తాను

931
00:45:26,100 --> 00:45:28,449
ఇన్పుట్ వివరించడానికి ఉపయోగించే
సందేశం, ఇంగ్లీష్ వంటి

932
00:45:28,449 --> 00:45:31,240
లేదా సంసార భాషలో మీరు నిజంగా
కొన్ని ఇతర మానవ పంపాలని.

933
00:45:31,240 --> 00:45:35,450
ఆపై సాంకేతికపాఠం పెనుగులాట ఉంది
enciphered, లేదా ఎన్క్రిప్టెడ్,

934
00:45:35,450 --> 00:45:36,520
దాని వెర్షన్.

935
00:45:36,520 --> 00:45:38,750
>> కానీ ఇక్కడ ఒక ఇతర వస్తువుల ఉంది.

936
00:45:38,750 --> 00:45:43,200
మరొకరు ఇన్పుట్ అక్కడ
రహస్య కీ గూఢ లిపి శాస్త్రం.

937
00:45:43,200 --> 00:45:45,200
మరియు ఆ కీ అనేది,
ఇది సాధారణంగా ఉంది,

938
00:45:45,200 --> 00:45:48,930
మేము చూస్తారు వంటి, ఒక సంఖ్య, లేదా
లేఖ, లేదా పదం, సంసార

939
00:45:48,930 --> 00:45:51,980
వాస్తవానికి ఇది అల్గోరిథం ఆశించారు.

940
00:45:51,980 --> 00:45:53,870
>> ఎలా మీరు వ్యక్తీకరించడానికి సమాచారం లేదు?

941
00:45:53,870 --> 00:45:55,110
ఎలా మీరు Unscramble చెయ్యాలి?

942
00:45:55,110 --> 00:45:57,950
బాగా, మీరు కేవలం రివర్స్
ఉద్గాతాలు మరియు ఇన్పుట్లను.

943
00:45:57,950 --> 00:46:00,900
>> ఇతర మాటలలో, ఎవరైనా ఒకసారి
మీ గుప్తీకరించిన సందేశాన్ని అందుకుంటుంది,

944
00:46:00,900 --> 00:46:03,740
అతను లేదా ఆమె కేవలం ఉంది
అదే కీ తెలుసుకోవటానికి.

945
00:46:03,740 --> 00:46:05,700
వారు సాంకేతికపాఠం అందింది.

946
00:46:05,700 --> 00:46:09,530
మరియు ఆ రెండు పూరించే ద్వారా
క్రిప్టో వ్యవస్థ ఇన్పుట్లను,

947
00:46:09,530 --> 00:46:14,260
అల్గోరిథం, ఈ బ్లాక్ బాక్స్ బయటకు
అసలు సాదా రావాల్సిందే.

948
00:46:14,260 --> 00:46:17,830
కాబట్టి చాలా అధిక స్థాయి
గూఢ లిపి శాస్త్రం అసలు దృష్టిలో

949
00:46:17,830 --> 00:46:18,590
అన్ని గురించి.

950
00:46:18,590 --> 00:46:20,030
>> కాబట్టి యొక్క పొందండి తెలియజేయండి.

951
00:46:20,030 --> 00:46:22,700
ఇప్పుడు క్రింద చూద్దాం
ఏదో హుడ్

952
00:46:22,700 --> 00:46:26,000
మేము మంజూరు కోసం తీసుకొని చేసిన
గత వారం, మరియు ఈ సెషన్

953
00:46:26,000 --> 00:46:27,629
స్ట్రింగ్ ఇక్కడ.

954
00:46:27,629 --> 00:46:30,295
రోజు చివరిలో ఒక స్ట్రింగ్
కేవలం అక్షరాలు క్రమం.

955
00:46:30,295 --> 00:46:33,610
>> అది హలో ప్రపంచ, లేదా
హలో, Zamyla, లేదా సంసార.

956
00:46:33,610 --> 00:46:37,050
అయితే అది అర్థం ఏమిటి
అక్షరాలు క్రమం ఉంటుంది?

957
00:46:37,050 --> 00:46:41,520
నిజానికి, CS50 లైబ్రరీ ఇస్తుంది
మాకు స్ట్రింగ్ అనే డేటా రకం.

958
00:46:41,520 --> 00:46:45,140
>> కానీ నిజానికి ఉండదు
C. లో ఒక స్ట్రింగ్ వంటి విషయం

959
00:46:45,140 --> 00:46:49,450
ఇది నిజంగా కేవలం ఒక వరుస క్రమం
పాత్ర, పాత్ర, పాత్ర,

960
00:46:49,450 --> 00:46:52,180
పాత్ర, తిరిగి, కు, వెనుకకు
తిరిగి, వెనుకకు లోపల వెనుకకు

961
00:46:52,180 --> 00:46:54,650
మీ కంప్యూటర్ యొక్క మెమరీ, లేదా RAM యొక్క.

962
00:46:54,650 --> 00:46:58,940
మరియు మనము ఆ లోతుగా పరిశీలిస్తాము
భవిష్యత్తులో మేము శ్రేణితో చూస్తున్నప్పుడు

963
00:46:58,940 --> 00:47:02,030
మరియు వినియోగం, మరియు
ఉన్నట్టుగా బెదిరింపులు.

964
00:47:02,030 --> 00:47:04,100
>> కానీ యొక్క స్ట్రింగ్ Zamyla పరిశీలిద్దాం.

965
00:47:04,100 --> 00:47:07,480
కాబట్టి కేవలం పేరు
ఇక్కడ మానవ, Zamyla,

966
00:47:07,480 --> 00:47:12,030
ఆ వరుస క్రమం
అక్షరాలు, Z- ఒక-M- వై ఎల్ ఎ.

967
00:47:12,030 --> 00:47:16,020
ఇప్పుడు యొక్క అనుకుందాం తెలియజేయండి అని, Zamyla యొక్క పేరు
కంప్యూటర్ లోపల నిల్వ ఉంది

968
00:47:16,020 --> 00:47:16,880
ప్రోగ్రామ్.

969
00:47:16,880 --> 00:47:20,830
>> సరే, మేము తప్పక కారణం ఉంది
ఆ అక్షరాలు చూడండి చెయ్యగలరు

970
00:47:20,830 --> 00:47:21,590
వ్యక్తిగతంగా.

971
00:47:21,590 --> 00:47:24,710
నేను కొంచెం డ్రా వెళుతున్న
ఇక్కడ Zamyla యొక్క పేరు చుట్టూ బాక్స్.

972
00:47:24,710 --> 00:47:31,580
మరియు అది సి లో కేసు ఉన్నప్పుడు మీరు ఆ
Zamyla-- మరియు ఉండవచ్చు వంటి, ఒక స్ట్రింగ్ కలిగి

973
00:47:31,580 --> 00:47:34,940
ఆ స్ట్రింగ్ నుండి తిరిగి వచ్చిన
స్ట్రింగ్ వంటి ఫంక్షన్,

974
00:47:34,940 --> 00:47:38,540
మీరు నిజంగా చేయవచ్చు
పాత్ర ద్వారా అది పాత్ర.

975
00:47:38,540 --> 00:47:42,070
>> ఇప్పుడు, ఈ కోసం సంబంధించి ఉంది
చేతిలో, ఎందుకంటే సంభాషణ

976
00:47:42,070 --> 00:47:46,420
నిఘూడ లేఖనంలో మీరు మార్చడానికి అనుకుంటే
B కి, మరియు B C వరకు, మరియు D సి ఎ,

977
00:47:46,420 --> 00:47:49,650
మొదలగునవి, మీరు చెయ్యగలరు అవసరం
వ్యక్తిగత అక్షరాలు చూడండి

978
00:47:49,650 --> 00:47:50,190
ఒక స్ట్రింగ్ లో.

979
00:47:50,190 --> 00:47:52,695
మీరు మార్చడానికి ఉండాలి
ఏదో, ఒక Z కు

980
00:47:52,695 --> 00:47:55,280
ఏదో అధికారి M
వేరే, మరియు అందువలన న ఏదో.

981
00:47:55,280 --> 00:47:58,000
అందువలన మేము ఒక మార్గం అవసరం,
programmatically, కాబట్టి

982
00:47:58,000 --> 00:48:03,020
సి లో, మాట్లాడటం మార్చగలరు ఉండాలి
మరియు వ్యక్తిగత అక్షరాలు చూడండి.

983
00:48:03,020 --> 00:48:05,690
క్రింది విధంగా మేము చేయవచ్చు.

984
00:48:05,690 --> 00:48:08,340
>> నాకు CS50 IDE లో తిరిగి తల వెళ్ళి తెలపండి.

985
00:48:08,340 --> 00:48:11,130
మరియు నాకు ముందుకు తెలియజేయండి
ఒక కొత్త ఫైలు సృష్టించవచ్చు

986
00:48:11,130 --> 00:48:16,134
నేను ఈ సమయంలో string0 పిలుస్తాను,
మా మొదటి అలాంటి ఉదాహరణగా, డాట్ సి.

987
00:48:16,134 --> 00:48:18,300
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న
ఉద్యమాలపై దానిని విప్.

988
00:48:18,300 --> 00:48:22,870
>> కనుక cs50.h ఉన్నాయి, మరియు
అప్పుడు ప్రామాణిక io.h ఉన్నాయి,

989
00:48:22,870 --> 00:48:25,990
ఇది నేను దాదాపు ఎల్లప్పుడూ వెళుతున్న
కనీసం, నా కార్యక్రమాలు ఉపయోగించి

990
00:48:25,990 --> 00:48:26,780
ప్రారంభంలో.

991
00:48:26,780 --> 00:48:32,180
ప్రధాన గర్జన Int, మరియు అప్పుడు ఇక్కడ నేను ఉన్నాను
తీగలను చేయబోవడం స్ట్రింగ్ పొందండి పొందుతాడు.

992
00:48:32,180 --> 00:48:35,260
ఆపై నేను వెళుతున్న
ముందుకు వెళ్ళి దీన్ని.

993
00:48:35,260 --> 00:48:37,460
నేను ముందుకు వెళ్లాలని మీరు
మరియు, ఒక తెలివి తనిఖీ,

994
00:48:37,460 --> 00:48:43,607
కేవలం చెప్పటానికి, హలో, శాతం లు,
సెమీ కోలన్, స్ట్రింగ్ 0 చేస్తుంది.

995
00:48:43,607 --> 00:48:44,690
అయ్యో, నేను ఇక్కడ ఏం చేసావ్?

996
00:48:44,690 --> 00:48:45,930
ఓహ్, నేను దానిని ప్రదర్శించాడు లేదు.

997
00:48:45,930 --> 00:48:48,120
కాబట్టి పాఠం, నేర్చుకునే
కావాలని కాదు.

998
00:48:48,120 --> 00:48:52,480
>> కాబట్టి లోపం, మరింత శాతం
డేటా వాదనలు కంటే మార్పిడులు.

999
00:48:52,480 --> 00:48:54,940
మరియు ఈ లో, పేరు
లైన్ 7-- సరే, నేను కలిగి,

1000
00:48:54,940 --> 00:48:56,690
కోట్ unquote, ఆ
printf నా స్ట్రింగ్.

1001
00:48:56,690 --> 00:48:58,151
నేను ఒక శాతం సైన్ పొందారు.

1002
00:48:58,151 --> 00:48:59,650
కానీ నేను మిస్ చేస్తున్నాను రెండవ వాదన.

1003
00:48:59,650 --> 00:49:03,190
>> నేను కామా లు, మిస్ చేస్తున్నాను ఇది
నేను గత ఉదాహరణలు ఉన్నాయి.

1004
00:49:03,190 --> 00:49:06,650
కనుక ఒక మంచి అవకాశం పరిష్కరించడానికి
ఒకటి కంటే తప్పు, అనుకోకుండా.

1005
00:49:06,650 --> 00:49:09,950
ఇప్పుడు నాకు అమలు అనుమతిస్తాయి
string0 లో, Zamyla రకం.

1006
00:49:09,950 --> 00:49:10,970
Zamyla హలో, సరే.

1007
00:49:10,970 --> 00:49:14,144
>> కాబట్టి మేము ఈ రకమైన కార్యక్రమం అమలు చేసిన
ఇప్పుడు కొన్ని వేర్వేరు సమయాల్లో.

1008
00:49:14,144 --> 00:49:16,310
కానీ యొక్క ఏదో ఒక తెలియజేసేలా
కొద్దిగా భిన్నంగా ఈ సమయంలో.

1009
00:49:16,310 --> 00:49:19,450
బదులుగా కేవలం Zamyla యొక్క ముద్రణ
printf తో బయటకు మొత్తం పేరు,

1010
00:49:19,450 --> 00:49:21,350
పాత్ర అది పాత్ర తెలియజేసేలా.

1011
00:49:21,350 --> 00:49:22,700
>> నేను లూప్ ఒక ఉపయోగించడానికి వెళుతున్న.

1012
00:49:22,700 --> 00:49:26,160
మరియు నేను ఇవ్వాలని వెళుతున్న
ఒక లెక్కించే వేరియబుల్, నేను అని.

1013
00:49:26,160 --> 00:49:33,530
నేను iterating ఉంచడానికి వెళుతున్న కాబట్టి,
నేను s యొక్క పొడవు కంటే తక్కువ కాలం.

1014
00:49:33,530 --> 00:49:35,930
>> ఇది అవుతుంది, మేము కాదు
ఈ చివరిసారి చేయండి,

1015
00:49:35,930 --> 00:49:39,100
సి ఒక వస్తుంది
ఫంక్షన్ స్టిర్లింగ్ అని.

1016
00:49:39,100 --> 00:49:42,690
తిరిగి రోజు, మరియు సాధారణంగా
విధులు అమలు ఇప్పటికీ ఉన్నప్పుడు,

1017
00:49:42,690 --> 00:49:45,405
మానవులు తరచుగా చాలా ఎన్నుకుంటుంది
సంక్షిప్తమైన పేర్లను ధ్వని ఆ రకమైన

1018
00:49:45,405 --> 00:49:48,280
మీరు ఏమి, అది అయినప్పటికీ వంటి
కొన్ని అచ్చులు లేదా లేఖలు లేదు.

1019
00:49:48,280 --> 00:49:50,660
కాబట్టి స్టిర్లింగ్ ఉంది
ఒక ఫంక్షన్ యొక్క పేరు అని

1020
00:49:50,660 --> 00:49:53,880
మధ్య ఒక వాదన పడుతుంది
ఒక స్ట్రింగ్ ఉండాలి కుండలీకరణాలు.

1021
00:49:53,880 --> 00:49:56,910
మరియు అది కేవలం ఒక పూర్ణాంకం తిరిగి,
ఆ స్ట్రింగ్ యొక్క పొడవు.

1022
00:49:56,910 --> 00:50:00,580
>> లైన్ 7 న ఈ లూప్ కాబట్టి అన్నారు
నేను 0 సమానం లెక్కింపు మొదలు.

1023
00:50:00,580 --> 00:50:02,530
దాన్ని పెంచడం జరగబోతోంది
ప్రతి పునరావృతం న నేను

1024
00:50:02,530 --> 00:50:04,350
1, మేము కొన్ని సార్లు చేయడం చేసిన.

1025
00:50:04,350 --> 00:50:06,780
కానీ ఇది కేవలం చేయాలని జరగబోతోంది
ఈ అప్ అప్పటివరకూ

1026
00:50:06,780 --> 00:50:09,660
నేను పొడవు ఉన్నప్పుడు
స్ట్రింగ్ యొక్క.

1027
00:50:09,660 --> 00:50:14,520
>> సో ఈ చివరకు ఒక మార్గం,
అక్షరాల కంటే iterating

1028
00:50:14,520 --> 00:50:17,430
స్ట్రింగ్ లో యధాతథంగా అనుసరిస్తుంది.

1029
00:50:17,430 --> 00:50:20,670
నేను ఒక నాటౌట్ ప్రింట్ వెళుతున్న
మొత్తం స్ట్రింగ్, కానీ శాతం సి,

1030
00:50:20,670 --> 00:50:22,860
ఒక పాత్ర
ఒక కొత్త పంక్తి తర్వాత.

1031
00:50:22,860 --> 00:50:24,880
ఆపై నేను వెళుతున్న
ముందుకు వెళ్ళి, మరియు నేను అవసరం

1032
00:50:24,880 --> 00:50:29,080
నేను ప్రింట్ అనుకుందాం
s యొక్క ith పాత్ర.

1033
00:50:29,080 --> 00:50:33,450
>> నేను సూచిస్తుంది వేరియబుల్ ఉంటే
స్ట్రింగ్, పేరు యొక్క ఇండెక్స్

1034
00:50:33,450 --> 00:50:37,230
మీరు వీటిని, నేను చెయ్యగలరు అవసరం
నాకు s యొక్క ith పాత్ర ఇవ్వాలని, చెప్పగలను.

1035
00:50:37,230 --> 00:50:40,390
మరియు సి చేయడం ఒక మార్గం ఉంది
చదరపు బ్రాకెట్లలో ఈ.

1036
00:50:40,390 --> 00:50:43,679
మీరు కేవలం పేరు చెప్పండి
స్ట్రింగ్, ఈ సందర్భంలో లు ఉంది.

1037
00:50:43,679 --> 00:50:46,970
అప్పుడు మీరు ఇది చదరపు బ్రాకెట్లలో ఉపయోగించడానికి
సాధారణంగా మీ తిరుగు ప్రయాణ లేదా Enter పైన

1038
00:50:46,970 --> 00:50:48,110
కీబోర్డ్ మీద కీ.

1039
00:50:48,110 --> 00:50:52,410
ఆపై మీరు ఇండెక్స్ చాలు
మీరు ముద్రించడానికి కావలసిన పాత్ర.

1040
00:50:52,410 --> 00:50:55,960
కాబట్టి ఇండెక్స్ ఒక అవతరిస్తుంది
సంఖ్య 0 లేదా 1, లేదా 2, లేదా 3, లేదా డాట్,

1041
00:50:55,960 --> 00:50:57,590
డాట్, డాట్, కొన్ని ఇతర సంఖ్య.

1042
00:50:57,590 --> 00:51:00,920
>> మరియు మేము అది జరగబోతోంది ఉండేలా
కుడి సంఖ్య ఉంటుంది నేను

1043
00:51:00,920 --> 00:51:02,360
0 వద్ద లెక్కింపు మొదలు.

1044
00:51:02,360 --> 00:51:07,020
సిద్ధ మొదటి మూర్తి
ఒక స్ట్రింగ్ లో దీనిపై 0 ద్వారా ఉంది.

1045
00:51:07,020 --> 00:51:09,230
మరియు రెండవ పాత్ర బ్రాకెట్ 1 ఉంది.

1046
00:51:09,230 --> 00:51:11,120
మరియు మూడవ పాత్ర బ్రాకెట్ 2.

1047
00:51:11,120 --> 00:51:13,630
మరియు మీరు చాలా వెళ్లాలనుకుంటే లేదు
ఇప్పటివరకు, కాని మేము ఉన్నాము ఎందుకంటే

1048
00:51:13,630 --> 00:51:17,780
మాత్రమే అది వరకు నేను పెంచడం అన్నారు
స్ట్రింగ్ యొక్క పొడవు సమానం.

1049
00:51:17,780 --> 00:51:20,210
మరియు అప్పుడు,
లూప్ ఈ ఆగిపోతుంది.

1050
00:51:20,210 --> 00:51:25,550
>> నాలో ముందుకు వెళ్లి ఈ అపహసించిరి
కార్యక్రమం, మరియు రన్ స్ట్రింగ్ 0 చేస్తాము.

1051
00:51:25,550 --> 00:51:28,400
కానీ నేను ఇరుక్కొనిపోయింది.

1052
00:51:28,400 --> 00:51:35,390
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ ప్రకటించారు
రకం ఇటువంటి తో స్టిర్లింగ్ మరియు ఇప్పుడు such--,

1053
00:51:35,390 --> 00:51:36,430
ఈ తెలిసిన ధ్వనులు.

1054
00:51:36,430 --> 00:51:37,440
కానీ అది printf కాదు.

1055
00:51:37,440 --> 00:51:38,540
మరియు అది స్ట్రింగ్ పొందండి కాదు.

1056
00:51:38,540 --> 00:51:40,480
>> నేను సైన్ అప్ మేకు లేదు
అదే విధంగా ఈ సమయం.

1057
00:51:40,480 --> 00:51:45,100
అయితే దీనిని ఇక్కడ కొంచెం డౌన్ గమనించవచ్చు
మరింత శీర్షిక string.h ఉన్నాయి,

1058
00:51:45,100 --> 00:51:47,210
నడిపేవారిని అందించడానికి
స్టిర్లింగ్ వాంగ్మూలము.

1059
00:51:47,210 --> 00:51:48,820
సో అక్కడ నిజానికి అక్కడ ఒక క్లూ ఉంది.

1060
00:51:48,820 --> 00:51:51,670
>> నిజానికి దాన్ని మారుతుంది
మరో శీర్షికా ఫైలును ఉంది

1061
00:51:51,670 --> 00:51:53,970
మనం ఉపయోగించని చేసిన
తరగతి లో ఇంకా, కానీ అది

1062
00:51:53,970 --> 00:51:56,480
అందుబాటులో వారిలో
మీకు, string.h అని.

1063
00:51:56,480 --> 00:52:00,930
మరియు ఆ ఫైలు, string.h లో
స్టిర్లింగ్ ప్రకటిస్తారు.

1064
00:52:00,930 --> 00:52:05,220
నాలో ముందుకు వెళ్లి
ఈ సేవ్ స్ట్రింగ్ చేయడానికి

1065
00:52:05,220 --> 00:52:08,040
0 ఉంది నైస్, ఏ లోపం సందేశాలు ఈ సమయంలో.

1066
00:52:08,040 --> 00:52:12,290
>> ./string0 Zamyla, మరియు
నేను ఎంటర్ నొక్కండి గురించి ఉన్నాను,

1067
00:52:12,290 --> 00:52:16,710
ఈ దశలో GetString అన్నారు
స్ట్రింగ్ తిరిగి s లో అది చాలు.

1068
00:52:16,710 --> 00:52:21,890
లూప్ iterate అన్నారు ఆ
ఒక సమయంలో ఒకటి కంటే S యొక్క అక్షరాలు,

1069
00:52:21,890 --> 00:52:28,420
మరియు వాటిని, పంక్తికి ఒకటి ప్రింట్ ఎందుకంటే
నేను చివరిలో ఆ బాక్ స్లాష్ n వచ్చింది.

1070
00:52:28,420 --> 00:52:34,530
నేను ఆ బాక్ స్లాష్ వదిలివేయు కాలేదు
n, మరియు కేవలం Zamyla ప్రింట్

1071
00:52:34,530 --> 00:52:37,460
అదే లైన్ లో,
సమర్థవంతంగా reimplementing

1072
00:52:37,460 --> 00:52:38,999
printf అన్ని ఆ ఉపయోగకరంగా ఉంది.

1073
00:52:38,999 --> 00:52:40,540
కానీ ఈ సందర్భంలో, నేను ఆ పని చెయ్యలేదు.

1074
00:52:40,540 --> 00:52:43,610
నేను నిజానికి ఒక ముద్రిత చేసిన
ఒక సమయంలో పాత్ర, లైన్కి

1075
00:52:43,610 --> 00:52:45,400
కాబట్టి మేము నిజానికి ప్రభావం చూసే.

1076
00:52:45,400 --> 00:52:46,900
>> కానీ నేను ఇక్కడ ఒక విషయం గమనించాలి.

1077
00:52:46,900 --> 00:52:48,930
మరియు మేము తిరిగి వచ్చి ఉంటుంది
భవిష్యత్ వారంలో ఈ.

1078
00:52:48,930 --> 00:52:52,650
ఈ హాజరవుతారు
కోడ్ సమర్థవంతంగా బగ్గీ ఉంది.

1079
00:52:52,650 --> 00:52:56,560
>> ఇది ఆ స్ట్రింగ్ పొందండి అవుతుంది
మరియు జీవితం లో కొన్ని ఇతర విధులు

1080
00:52:56,560 --> 00:53:00,280
తప్పనిసరిగా ఎల్లప్పుడూ లేదు
మీరు ఆశించే ఏమి తిరిగి.

1081
00:53:00,280 --> 00:53:03,010
మేము గత తరగతి నుండి తెలుసు
పొందిన ఈ సమయం

1082
00:53:03,010 --> 00:53:04,960
స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి కోరుకుంటున్నాము.

1083
00:53:04,960 --> 00:53:09,900
కానీ ఏమి యూజర్ రకాలైన బయటకు ఉంటే
దీర్ఘ పదం లేదా పేరాగ్రాఫ్, లేదా వ్యాసంలో

1084
00:53:09,900 --> 00:53:13,010
తగినంత కేవలం ఉందని
కంప్యూటర్ లో మెమరీ సరిపోయే.

1085
00:53:13,010 --> 00:53:15,410
>> ఇలా, ఏమి ఏదో పోతే
హుడ్ కింద తప్పు?

1086
00:53:15,410 --> 00:53:18,400
ఇది తరచుగా ఏమి కాదు,
కానీ ఒకప్పుడు జరిగి

1087
00:53:18,400 --> 00:53:21,520
ఒక సమయంలో, చాలా అరుదుగా.

1088
00:53:21,520 --> 00:53:25,460
కాబట్టి ఆ స్ట్రింగ్ అవుతుంది
మరియు అది వంటి విధులు అవసరం లేదు

1089
00:53:25,460 --> 00:53:26,380
ఎల్లప్పుడూ తీగలను తిరిగి.

1090
00:53:26,380 --> 00:53:30,680
వారు కొన్ని లోపం విలువ తిరిగి ఉండవచ్చు,
కొన్ని సెంటినెల్ విలువ మాట్లాడటానికి,

1091
00:53:30,680 --> 00:53:32,612
ఆ సూచిస్తుంది
ఏదో సమస్య ఉంది.

1092
00:53:32,612 --> 00:53:35,320
మరియు మీరు మాత్రమే ఈ తెలుసు అని
ఇప్పుడు తరగతి లో చదివి వుండడం వల్ల

1093
00:53:35,320 --> 00:53:37,700
లేదా కొన్ని మరింత డాక్యుమెంటేషన్ చదవండి కలిగి.

1094
00:53:37,700 --> 00:53:43,120
ఇది ఆ స్ట్రింగ్ పొందండి అవుతుంది
శూన్య అనే విలువ తిరిగి.

1095
00:53:43,120 --> 00:53:46,220
శూన్య మేము చేస్తాము ఒక ప్రత్యేక విలువ
భవిష్యత్ వారంలో తిరిగి వస్తారు.

1096
00:53:46,220 --> 00:53:50,420
కానీ ఇప్పుడు కోసం, కేవలం నేను అనుకుంటే తెలుసు
ముందుకు వెళ్లడానికి నిజంగా సరైన ఉండాలి

1097
00:53:50,420 --> 00:53:52,650
స్ట్రింగ్ ఉపయోగించి, నేను
కేవలం కాల్ కాదు,

1098
00:53:52,650 --> 00:53:56,870
మరియు గుడ్డిగా తిరిగి విలువ ఉపయోగించడానికి,
అది ఒక స్ట్రింగ్ ఉంది నమ్ముతూ.

1099
00:53:56,870 --> 00:53:59,420
>> నేను మొదటి, చెప్పాలి
హే, మాత్రమే, ఒక నిమిషం వేచి

1100
00:53:59,420 --> 00:54:03,380
లు సమానం కాదు ఉంటే వెళ్లండి
శూన్య పేరు శూన్య, మళ్ళీ,

1101
00:54:03,380 --> 00:54:04,660
కేవలం కొన్ని ప్రత్యేక విలువ.

1102
00:54:04,660 --> 00:54:07,770
మరియు అది మాత్రమే ప్రత్యేక విలువ వార్తలు మీరు
స్ట్రింగ్ గురించి ఆందోళన అవసరం.

1103
00:54:07,770 --> 00:54:10,900
స్ట్రింగ్ గాని అన్నారు పొందండి
ఒక స్ట్రింగ్ లేదా శూన్య తిరిగి.

1104
00:54:10,900 --> 00:54:17,219
>> మరియు ఈ ఆశ్చర్యార్థకం పాయింట్ సైన్ సమానం
మీరు బహుశా గణిత తరగతి నుండి తెలిసిన

1105
00:54:17,219 --> 00:54:20,510
మీతో సమాన సైన్ డ్రా ఉండవచ్చు
ద్వారా లైన్ సమానం కాదు సూచించడానికి.

1106
00:54:20,510 --> 00:54:23,135
ఆ సాధారణంగా ఒక పాత్ర కాదు
మీరు మీ కీబోర్డు మీద టైప్ చేయవచ్చు.

1107
00:54:23,135 --> 00:54:26,480
అందుకనే ప్రోగ్రామింగ్ భాషల్లో,
మీరు సమానంగా కాదు చెప్పే,

1108
00:54:26,480 --> 00:54:29,160
మీరు ఒక ఆశ్చర్యార్థకం పాయింట్ ఉపయోగించండి,
లేకపోతే బ్యాంగ్ అని పిలుస్తారు.

1109
00:54:29,160 --> 00:54:33,180
సో మీరు బ్యాంగ్ సమానం చెప్పవు
న్యాయంగా, సమానం అర్థం.

1110
00:54:33,180 --> 00:54:38,060
ఇది ఒక గొప్ప అక్కడ కాదు కేవలం వంటిది
కంటే, లేదా కంటే తక్కువ సమానంగా, లేదా

1111
00:54:38,060 --> 00:54:41,270
లేదా మీ కీబోర్డు మీద కీ సమానంగా
ఒక చిహ్నంగా అది అన్ని చేస్తుంది.

1112
00:54:41,270 --> 00:54:44,020
కాబట్టి ఆ వై గత ఉదాహరణలలో,
మీరు ఒక ఓపెన్ బ్రాకెట్, ఆపై

1113
00:54:44,020 --> 00:54:48,670
సమాన సైన్, క్రమంలో చేయాలి
కంటే ఎక్కువ లేదా, చెప్పటానికి కంటే తక్కువ.

1114
00:54:48,670 --> 00:54:49,910
>> సో వాట్ ఇక్కడ takeaway ఏమిటి?

1115
00:54:49,910 --> 00:54:53,880
ఈ సాధారణంగా ఇప్పుడు ఒక మార్గం
ఈ వాక్యనిర్మాణం పరిచయం, ఈ ఫీచర్

1116
00:54:53,880 --> 00:54:57,390
వ్యక్తిగత పైగా iterating
ఒక స్ట్రింగ్ లో అక్షరాలు.

1117
00:54:57,390 --> 00:55:00,260
మరియు కేవలం ఆ చదరపు
బ్రాకెట్లలో, మీరు వాటిని పొందడానికి అనుమతిస్తుంది

1118
00:55:00,260 --> 00:55:03,790
ఆ చదరపు బ్రాకెట్లలో పరిగణలోకి
రకమైన ఈ అంతర్లీన తెలుపుతున్న ఈ నిక్షిప్త

1119
00:55:03,790 --> 00:55:06,040
డిజైన్, ఇందులో ప్రతి
ఒక స్ట్రింగ్ లోపల పాత్ర

1120
00:55:06,040 --> 00:55:10,180
రకమైన కింద ఎక్కడో లో బాక్స్డ్ ఉంది
మీ కంప్యూటర్ యొక్క మెమరీ లో హుడ్.

1121
00:55:10,180 --> 00:55:12,340
>> కానీ యొక్క ఈ యొక్క ఒక వైవిధ్యం తయారు చేద్దాము.

1122
00:55:12,340 --> 00:55:14,880
ఈ హాజరవుతారు
ప్రోగ్రామ్ సరైనది.

1123
00:55:14,880 --> 00:55:18,810
కాబట్టి CS50 యొక్క అక్షాలు శాతం లెక్కించడంలో
కోడ్, ఈ ఇప్పుడు సరైనది.

1124
00:55:18,810 --> 00:55:22,959
ముఖ్యంగా ఇప్పుడు నేను తనిఖీ చేస్తున్నాను అని
శూన్య, ఈ కార్యక్రమం క్రాష్ ఎప్పుడూ.

1125
00:55:22,959 --> 00:55:24,500
మరియు నేను అనుభవం నుండి తెలుసు.

1126
00:55:24,500 --> 00:55:28,040
కానీ వేరే ఏదీ లేదు
మేము నిజంగా ఇక్కడ తప్పు వెళ్ళవచ్చు.

1127
00:55:28,040 --> 00:55:31,860
కానీ అది చాలా బాగా రూపకల్పన లేదు,
యొక్క బేసిక్స్ తిరిగి వెళ్ళి తెలపండి ఎందుకంటే.

1128
00:55:31,860 --> 00:55:34,450
>> మొదటి, principles--
లూప్ ఒక ఏమి చేస్తుంది?

1129
00:55:34,450 --> 00:55:36,290
లూప్ ఒక మూడు పనులు.

1130
00:55:36,290 --> 00:55:39,340
ఇది కొన్ని ప్రారంభించటానికి
విలువ, మీరు దానిని అడిగితే.

1131
00:55:39,340 --> 00:55:41,770
ఇది ఒక పరిస్థితి వెతుకుతుంది.

1132
00:55:41,770 --> 00:55:45,380
మరియు ప్రతి తర్వాత
మళ్ళా, ప్రతి చక్రం తర్వాత,

1133
00:55:45,380 --> 00:55:49,330
అది కొన్ని ఇంక్రిమెంట్
విలువ, లేదా విలువల ఇక్కడ.

1134
00:55:49,330 --> 00:55:50,600
>> కాబట్టి ఆ అర్థం ఏమిటి?

1135
00:55:50,600 --> 00:55:52,940
మేము నేను 0 ప్రారంభించడం.

1136
00:55:52,940 --> 00:55:58,610
మేము తనిఖీ నిర్ధారించుకోండి నేను కంటే తక్కువ ఉంది
ఇది Z-A-M- వై ఎల్-A గా s యొక్క పొడవు,

1137
00:55:58,610 --> 00:55:59,900
కాబట్టి 6 కంటే తక్కువ.

1138
00:55:59,900 --> 00:56:02,590
మరియు, నిజానికి, 0 6 కంటే తక్కువగా.

1139
00:56:02,590 --> 00:56:05,580
>> మేము Zamyla యొక్క పేరు నుండి Z ప్రింట్.

1140
00:56:05,580 --> 00:56:08,080
అప్పుడు మేము i పెంచడం 0 నుండి 1 కు.

1141
00:56:08,080 --> 00:56:11,290
మేము అప్పుడు, తనిఖీ 1 తక్కువ ఉంది
s యొక్క పొడవు కంటే?

1142
00:56:11,290 --> 00:56:13,270
లు పొడవు 6.

1143
00:56:13,270 --> 00:56:13,950
అవును, అది ఉంది.

1144
00:56:13,950 --> 00:56:16,880
>> కాబట్టి మేము Zamyla యొక్క పేరు, ZA ఒక ప్రింట్.

1145
00:56:16,880 --> 00:56:20,090
మేము i 0, 1, 2 వరకు పెంచడం.

1146
00:56:20,090 --> 00:56:23,720
మేము అప్పుడు, తనిఖీ కంటే 2 తక్కువ
Zamyla యొక్క పేరు యొక్క పొడవు.

1147
00:56:23,720 --> 00:56:25,380
6- కాబట్టి 2 6 కంటే తక్కువగా ఉంటుంది.

1148
00:56:25,380 --> 00:56:30,460
అవును, యొక్క ఎం ఇప్పుడు ప్రింట్ తెలియజేయండి
Zamyla యొక్క పేరు, మూడవ పాత్ర.

1149
00:56:30,460 --> 00:56:34,110
>> ఇక్కడ కీ ప్రతి చెప్పును
కథ మళ్ళా, నేను తనిఖీ చేస్తున్నాను,

1150
00:56:34,110 --> 00:56:37,810
నేను Zamyla యొక్క పొడవు కంటే తక్కువ?

1151
00:56:37,810 --> 00:56:40,350
కానీ క్యాచ్ ఉంది
స్టిర్లింగ్ స్వభావము కాదు.

1152
00:56:40,350 --> 00:56:43,100
ప్రోగ్రాం చేశారు ఎవరు మీరు యొక్క ఆ
జావా లేదా ఇతర భాషలలో ముందు

1153
00:56:43,100 --> 00:56:46,310
ఒక స్ట్రింగ్ యొక్క పొడవు తెలిసిన
ఒక ఆస్తి, కేవలం కొన్ని మాత్రమే విలువ చదవండి.

1154
00:56:46,310 --> 00:56:50,220
>> ఈ విషయంలో సి లో, ఉంటే ఈ ఉంది
అక్షరాలా అని ఒక ఫంక్షన్

1155
00:56:50,220 --> 00:56:53,520
సంఖ్యపై
ప్రతిసారీ Zamyla అక్షరాలు

1156
00:56:53,520 --> 00:56:54,740
మేము ఆ ఫంక్షన్ కాల్.

1157
00:56:54,740 --> 00:56:58,500
మీరు ఉపయోగించడానికి కంప్యూటర్లో అడగండి ప్రతిసారీ
స్టిర్లింగ్, అది Zamyla పరిశీలించి తీసుకొని

1158
00:56:58,500 --> 00:57:01,960
మరియు మాట్లాడుతూ Z-A-M- వై ఎల్-ఎ, 6.

1159
00:57:01,960 --> 00:57:02,962
మరియు అది 6 తిరిగి.

1160
00:57:02,962 --> 00:57:04,920
మీరు కాల్ తదుపరి సమయం
లూప్ ఆ లోపలి,

1161
00:57:04,920 --> 00:57:08,610
ఇది Zamyla చూడండి జరగబోతోంది
మళ్ళీ, చెప్పటానికి Z-A-M- వై ఎల్-ఎ, 6.

1162
00:57:08,610 --> 00:57:10,320
మరియు అది 6 తిరిగి వెళుతున్న.

1163
00:57:10,320 --> 00:57:12,980
కాబట్టి ఈ డిజైన్ గురించి స్టుపిడ్?

1164
00:57:12,980 --> 00:57:17,700
>> ఎందుకు నా ఒక 5 బయటకు 5 కోడ్
ప్రస్తుతం రూపకల్పనకు, మాట్లాడటానికి?

1165
00:57:17,700 --> 00:57:20,600
Well, నేను అడగడం నేను ఒక
అనవసరంగా ప్రశ్న.

1166
00:57:20,600 --> 00:57:23,030
నేను అవసరం కంటే నేను ఎక్కువ పని చేస్తున్నాను.

1167
00:57:23,030 --> 00:57:25,370
>> కాబట్టి అయినప్పటికీ
సమాధానం నేను సరైనది

1168
00:57:25,370 --> 00:57:29,560
కంప్యూటర్ అడుగుతూ, ఏమిటి
మళ్ళీ, Zamyla యొక్క పొడవు,

1169
00:57:29,560 --> 00:57:31,380
మళ్ళీ, మళ్ళీ, మళ్ళీ?

1170
00:57:31,380 --> 00:57:33,980
మరియు ఆ సమాధానం
మార్చడానికి ఎప్పుడూ వెళుతున్న.

1171
00:57:33,980 --> 00:57:35,900
ఇది ఎల్లప్పుడూ 6 చేస్తాడు.

1172
00:57:35,900 --> 00:57:39,730
>> ఈ కంటే సో ఒక మంచి పరిష్కారం
ఈ తదుపరి వెర్షన్ అని.

1173
00:57:39,730 --> 00:57:43,390
నాకు ముందుకు వెళ్లి ఒక లో ఉంచండి
string1.c అని ప్రత్యేక ఫైలు,

1174
00:57:43,390 --> 00:57:44,990
కేవలం అది వేరుగా ఉంచడానికి.

1175
00:57:44,990 --> 00:57:47,260
మరియు అది ఒక హాజరవుతారు
లూప్, మీరు వాస్తవానికి

1176
00:57:47,260 --> 00:57:50,210
ఒకేసారి బహుళ వేరియబుల్స్ డిక్లేర్.

1177
00:57:50,210 --> 00:57:53,460
>> నేను నేను ఉంచడానికి మరియు 0 దాన్ని సెట్ వెళుతున్న.

1178
00:57:53,460 --> 00:57:56,190
కానీ నేను కూడా వెళుతున్న
ఒక కామా జోడించడానికి, మరియు సే

1179
00:57:56,190 --> 00:58:01,050
నాకు n అనే వేరియబుల్, దీని ఇవ్వాలని
విలువ స్ట్రింగ్ s యొక్క పొడవు సమానం.

1180
00:58:01,050 --> 00:58:09,410
మరియు ఇప్పుడు, నా పరిస్థితి దయచేసి
కాబట్టి నేను కంటే తక్కువ n వంటి.

1181
00:58:09,410 --> 00:58:14,140
>> కాబట్టి ఈ విధంగా, తర్కం
రోజు చివరిలో ఒకేలా.

1182
00:58:14,140 --> 00:58:18,280
కానీ నేను గుర్తు చేస్తున్నాను
విలువ 6, ఈ విషయంలో.

1183
00:58:18,280 --> 00:58:19,780
Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?

1184
00:58:19,780 --> 00:58:20,860
మరియు నేను n ఉంచారు చేస్తున్నాను.

1185
00:58:20,860 --> 00:58:23,050
>> మరియు నేను ఇప్పటికీ తనిఖీ చేస్తున్నాను
పరిస్థితి ప్రతిసారీ.

1186
00:58:23,050 --> 00:58:24,300
0 6 కంటే తక్కువ?

1187
00:58:24,300 --> 00:58:25,600
1 6 కంటే తక్కువ?

1188
00:58:25,600 --> 00:58:28,600
6 కంటే 2 తక్కువ, మొదలగునవి?

1189
00:58:28,600 --> 00:58:31,914
>> కానీ నేను కంప్యూటర్ అడగడం లేదు
మళ్ళీ, మళ్ళీ, ఏమిటి

1190
00:58:31,914 --> 00:58:33,080
Zamyla యొక్క పేరు యొక్క పొడవు?

1191
00:58:33,080 --> 00:58:34,320
Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?

1192
00:58:34,320 --> 00:58:35,986
ఈ Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?

1193
00:58:35,986 --> 00:58:40,440
నేను వాచ్యంగా గుర్తు చేస్తున్నాను మొదటి మరియు
ఈ రెండవ వేరియబుల్ n లో మాత్రమే సమాధానం.

1194
00:58:40,440 --> 00:58:45,280
కాబట్టి ఈ ఇప్పుడు మాత్రమే అవుతుంది
సరి, కానీ కూడా బాగా రూపకల్పన.

1195
00:58:45,280 --> 00:58:46,670
>> ఇప్పుడు, శైలి గురించి ఏమి?

1196
00:58:46,670 --> 00:58:48,866
నేను నా వేరియబుల్స్ అనే చేసిన
అందంగా బాగా, నేను చెబుతా.

1197
00:58:48,866 --> 00:58:50,240
వారు ప్రస్తుతం సూపర్ క్లుప్తమైన.

1198
00:58:50,240 --> 00:58:52,090
మరియు ఆ పూర్తిగా మంచిది.

1199
00:58:52,090 --> 00:58:55,120
>> మీరు కేవలం ఒక కలిగి ఉంటే
ఒక కార్యక్రమం లో స్ట్రింగ్

1200
00:58:55,120 --> 00:58:56,860
మీరు అలాగే అది స్ట్రింగ్ కోసం s కాల్ ఉండవచ్చు.

1201
00:58:56,860 --> 00:58:59,370
మీరు మాత్రమే ఒక వేరియబుల్ కలిగి ఉంటే
ఒక కార్యక్రమంలో లెక్కింపు కోసం,

1202
00:58:59,370 --> 00:59:00,710
మీరు అలాగే నేను కాల్ ఉండవచ్చు.

1203
00:59:00,710 --> 00:59:03,500
మీరు ఒక పొడవు కలిగి ఉంటే, n
అలాగే సూపర్ సాధారణం.

1204
00:59:03,500 --> 00:59:05,800
కానీ నేను నా కోడ్ ఏ వ్యాఖ్యానించాడు.

1205
00:59:05,800 --> 00:59:09,200
>> నేను reader-- తెలియజేయలేదని చేసిన
నా TF, టిఎ అయినా,

1206
00:59:09,200 --> 00:59:12,460
లేదా కేవలం కోరుకుంటున్నాము ఏమి colleague--
ఈ కార్యక్రమంలో లో వెళ్ళడం.

1207
00:59:12,460 --> 00:59:15,760
కాబట్టి మంచి శైలి పొందడానికి,
నేను చేయాలనుకుంటున్నారా ఏమి

1208
00:59:15,760 --> 00:59:24,580
దీన్ని విషయం
వంటి ఇన్పుట్ కోసం వినియోగదారు అడగండి.

1209
00:59:24,580 --> 00:59:26,670
నేను తిరిగి భావిస్తున్నారు
మార్గాల్లో సంఖ్య ఈ.

1210
00:59:26,670 --> 00:59:35,630
>> చేయండి s-- ఖచ్చితంగా పొందండి నిర్ధారించుకోండి
స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి.

1211
00:59:35,630 --> 00:59:40,280
మరియు ఇక్కడ అప్పుడు మరియు ఈ బహుశా ఉంది
అతి ముఖ్యమైన comment-- iterate

1212
00:59:40,280 --> 00:59:44,450
ఒక సమయంలో ఒక దానివెంట ఒకటి లో అక్షరాల కంటే.

1213
00:59:44,450 --> 00:59:47,060
నేను ఏ వాడవచ్చు
ఇంగ్లీష్ భాష యొక్క ఎంపిక

1214
00:59:47,060 --> 00:59:49,650
ఇక్కడ ప్రతి వివరించడానికి
కోడ్ యొక్క ఈ రాళ్లను.

1215
00:59:49,650 --> 00:59:52,740
>> నేను ఒక పెట్టలేదు గమనించవచ్చు
కోడ్ యొక్క ప్రతి లైన్ మీద మీరే,

1216
00:59:52,740 --> 00:59:55,690
నిజంగా కేవలం ఆసక్తికరమైన న
వాటిని, వాటిని ఆ

1217
00:59:55,690 --> 00:59:59,460
కొన్ని అర్థం కలిగి నేను వాటిని
ఎవరైనా సూపర్ స్పష్టంగా అనుకుంటున్నారా

1218
00:59:59,460 --> 01:00:00,460
నా కోడ్ చదవడం.

1219
01:00:00,460 --> 01:00:02,920
ఎందుకు మీరు పొందుటకు పిలుపునిస్తున్నాయి
స్ట్రింగ్ ఇన్పుట్ వినియోగదారుని అభ్యర్థించడం?

1220
01:00:02,920 --> 01:00:05,450
కూడా ఒక అవసరం లేదు
అన్ని వివరణాత్మక.

1221
01:00:05,450 --> 01:00:09,340
కానీ అది ఒక కథను సహాయపడుతుంది ఎందుకంటే
కథలో రెండవ లైన్ నిర్ధారించుకోండి

1222
01:00:09,340 --> 01:00:10,740
స్ట్రింగ్ పొందండి ఒక స్ట్రింగ్ తిరిగి.

1223
01:00:10,740 --> 01:00:14,260
>> కథలోని మూడవ లైన్ ఉంది
ఏడాదిన్నరలో లో అక్షరాల కంటే iterate

1224
01:00:14,260 --> 01:00:15,380
ఒక సమయంలో.

1225
01:00:15,380 --> 01:00:17,920
ఇప్పుడు కేవలం మంచి కొలత కోసం,
నేను ముందుకు వెళ్లి జోడించండి వెళుతున్న

1226
01:00:17,920 --> 01:00:24,560
ఒకటి కంటే వ్యాఖ్యను కేవలం
s లో ప్రింట్ నేను-వ పాత్ర అన్నారు.

1227
01:00:24,560 --> 01:00:26,520
ఇప్పుడు, ఏమి నేను చేసిన
రోజు చివరిలో?

1228
01:00:26,520 --> 01:00:29,190
>> నేను కొన్ని ఆంగ్ల చేర్చారు
వ్యాఖ్యలు రూపంలో పదాలు.

1229
01:00:29,190 --> 01:00:32,700
స్లాష్ స్లాష్ చిహ్నం, హే,
కంప్యూటర్ ఈ మానవ కోసం,

1230
01:00:32,700 --> 01:00:33,820
మీరు కోసం కాదు, కంప్యూటర్.

1231
01:00:33,820 --> 01:00:35,119
కాబట్టి అవి తార్కికంగా నిర్లక్ష్యం చేస్తున్నారు.

1232
01:00:35,119 --> 01:00:35,910
వారు అక్కడే ఉన్నారు.

1233
01:00:35,910 --> 01:00:39,830
>> మరియు, నిజానికి, CS50 IDE వాటిని చూపిస్తుంది
బూడిద, ఉపయోగకరమైన, కానీ కీ ఉండటం వంటి

1234
01:00:39,830 --> 01:00:41,000
కార్యక్రమానికి.

1235
01:00:41,000 --> 01:00:42,570
మీరు ఇప్పుడు ఏమి గమనించి.

1236
01:00:42,570 --> 01:00:44,950
మీరు C తెలుసు అని
ప్రోగ్రామింగ్ లేదా, మీకు

1237
01:00:44,950 --> 01:00:47,722
ఈ వద్ద తిరిగి నిలవదు
కార్యక్రమం మరియు వ్యాఖ్యల చెడిపోయిన.

1238
01:00:47,722 --> 01:00:50,180
నిర్ధారించుకోండి, ఇన్పుట్ యూజర్ అడగండి
స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి పొందడానికి,

1239
01:00:50,180 --> 01:00:53,009
లు లో అక్షరాల కంటే iterate
ఒక సమయంలో ఒక పాత్ర ప్రింట్

1240
01:00:53,009 --> 01:00:55,550
i-th పాత్ర s-- మీరు లేదు
కూడా కోడ్ చూడటానికి కలిగి

1241
01:00:55,550 --> 01:00:57,270
ఈ కార్యక్రమం ఏమి అర్థం.

1242
01:00:57,270 --> 01:01:00,280
మరియు, మంచి ఇంకా, మీరే చూడండి
ఒక వారం లేదా రెండు ఈ కార్యక్రమం,

1243
01:01:00,280 --> 01:01:02,280
లేదా ఒక నెల, లేదా ఒక సంవత్సరం,
మీరు చాలా లేదు

1244
01:01:02,280 --> 01:01:04,420
కోడ్ తీక్షణముగా,
గుర్తు ప్రయత్నిస్తున్న,

1245
01:01:04,420 --> 01:01:06,630
నేను ఈ కోడ్ తో ప్రయత్నిస్తున్న?

1246
01:01:06,630 --> 01:01:07,770
>> మీకు మీరే తెలిపియున్నాను.

1247
01:01:07,770 --> 01:01:11,660
మీరు మీ కోసం ఇది వివరించిన చేసిన,
లేదా కొన్ని సహోద్యోగి, లేదా TA లేదా TF.

1248
01:01:11,660 --> 01:01:14,860
కాబట్టి ఈ ఇప్పుడు ఉంటుంది
సరైన, మరియు మంచి డిజైన్,

1249
01:01:14,860 --> 01:01:18,210
మరియు చివరికి మంచి శైలి అలాగే.

1250
01:01:18,210 --> 01:01:19,990
కాబట్టి గుర్తుంచుకోండి లేదు.

1251
01:01:19,990 --> 01:01:22,200
>> కాబట్టి ఇతర ఒక ఉంది
విషయం నేను ఇక్కడ చేయ బోతున్నాను

1252
01:01:22,200 --> 01:01:28,240
ఇప్పుడు సరిగ్గా ఏమిటి చాటుతుంది
హుడ్ కింద జరగబోతోంది.

1253
01:01:28,240 --> 01:01:30,390
కాబట్టి ఈ ఫీచర్
C, మరియు ఇతర భాషలలో,

1254
01:01:30,390 --> 01:01:33,010
ఒకే రకం పాత్రలు చేయడం అనే
గాని పరిపూర్ణంగా

1255
01:01:33,010 --> 01:01:37,250
లేదా స్పష్టంగా మీరు మార్చేందుకు అనుమతిస్తుంది
ఒక డేటా రకాన్ని మరొక నుండి.

1256
01:01:37,250 --> 01:01:39,800
కాబట్టి మేము వ్యవహరించే చేసిన
తీగలను ఇప్పటివరకు నేడు.

1257
01:01:39,800 --> 01:01:41,250
>> మరియు తీగలను పాత్రలు.

1258
01:01:41,250 --> 01:01:44,910
కానీ వారం నుండి రీకాల్
0, అక్షరాలు ఏవి?

1259
01:01:44,910 --> 01:01:49,334
పాత్రలు కేవలం ఒక సంగ్రహణం ఉన్నాయి
సంఖ్యల దశాంశ సంఖ్యలు పైన,

1260
01:01:49,334 --> 01:01:52,500
మరియు దశాంశ సంఖ్యలు కేవలం ఒక నిజంగా ఉన్నాయి
ద్వియాంశ సంఖ్యల యొక్క పైన నైరూప్యత,

1261
01:01:52,500 --> 01:01:53,720
మేము అది నిర్వచించిన.

1262
01:01:53,720 --> 01:01:55,540
>> కాబట్టి అక్షరాలు నంబర్లు.

1263
01:01:55,540 --> 01:01:58,410
మరియు సంఖ్యలను అక్షరాలు ఉంటాయి,
కేవలం సందర్భం బట్టి.

1264
01:01:58,410 --> 01:02:01,250
మరియు అది లోపల అవుతుంది
ఒక కంప్యూటర్ ప్రోగ్రామ్ యొక్క,

1265
01:02:01,250 --> 01:02:06,830
మీరు చూడవచ్చు ఎలా పేర్కొనవచ్చు
ఆ ప్రోగ్రాం యొక్క లోపల బిట్స్?

1266
01:02:06,830 --> 01:02:10,400
>> వారం 0 మేము ఉందని నుండి రీకాల్
ఇది కేవలం ఈ కోడ్ చేసిన ASCII,

1267
01:02:10,400 --> 01:02:11,620
సంఖ్యలు మ్యాపింగ్ అక్షరాలు.

1268
01:02:11,620 --> 01:02:13,660
మరియు మేము రాజధాని 65, అన్నాడు.

1269
01:02:13,660 --> 01:02:15,860
రాజధాని B మొదలగునవి 66, మరియు.

1270
01:02:15,860 --> 01:02:20,500
>> మరియు నోటీసు, మేము తప్పనిసరిగా అక్షరాలు కలిగి
ఇక్కడ పై వరుస, సి వాటిని అంటారని వంటి,

1271
01:02:20,500 --> 01:02:23,400
అక్షరాలు, ఆపై
రెండవ వరుసలో మీద ints.

1272
01:02:23,400 --> 01:02:28,180
మరియు మీరు మార్చగలదు అవుతుంది
seamlessly రెండు, సాధారణంగా మధ్య.

1273
01:02:28,180 --> 01:02:30,042
మరియు మేము అలా అనుకుంటే
ఉద్దేశపూర్వకంగా, మేము

1274
01:02:30,042 --> 01:02:31,750
అధిగమించేందుకు అనుకోవచ్చు
ఇలాంటిది ఏదైనా.

1275
01:02:31,750 --> 01:02:33,590
>> మేము మార్చే కావలసిన ఉండవచ్చు
తగ్గుతాయని అప్పర్ కేస్

1276
01:02:33,590 --> 01:02:35,330
కేసు, లేదా అప్పర్ కేస్ తక్కువ కేసు.

1277
01:02:35,330 --> 01:02:38,000
మరియు అది ఉంది హాజరవుతారు
ఇక్కడ నిజానికి ఒక నమూనా

1278
01:02:38,000 --> 01:02:39,900
మేము కేవలం ఒక క్షణం లో స్వీకరించి.

1279
01:02:39,900 --> 01:02:44,120
కానీ యొక్క ఒక వద్ద మొదటి చూద్దాం
ప్రత్యేకంగా ఈ చేయడం ఉదాహరణ.

1280
01:02:44,120 --> 01:02:46,340
>> నేను CS50 IDE తిరిగి వెళ్ళడానికి వెళుతున్న.

1281
01:02:46,340 --> 01:02:50,640
నేను ఒక సృష్టించడానికి వెళుతున్న
ASCII 0.c. అనే ఫైల్

1282
01:02:50,640 --> 01:02:55,960
మరియు నేను ముందుకు వెళ్లి జోడించండి వెళుతున్న నా
ఎగువన ప్రామాణిక io.h, Int ప్రధాన గర్జన

1283
01:02:55,960 --> 01:02:57,370
నా ఫంక్షన్ ఎగువన.

1284
01:02:57,370 --> 01:03:02,700
మరియు తర్వాత నేను చేయ బోతున్నాను
నేను సమానం నుండి లూప్ ఒక కింది,

1285
01:03:02,700 --> 01:03:04,610
సే, 65 వీలు.

1286
01:03:04,610 --> 01:03:10,460
>> ఆపై నేను కంటే తక్కువ అవతరిస్తుంది
వర్ణమాలలో 65, ప్లస్ 26 అక్షరాలు.

1287
01:03:10,460 --> 01:03:12,640
కాబట్టి నేను కంప్యూటర్ తెలియజేస్తాము
అక్కడ నాకు గణిత చేయండి.

1288
01:03:12,640 --> 01:03:15,100
మరియు ఈ లూప్ లోపల,
నేను ప్రింట్ వెళ్తున్నాను?

1289
01:03:15,100 --> 01:03:19,230
>> % సి ఐ బ్యాక్స్లాష్ n% ఉంది.

1290
01:03:19,230 --> 01:03:21,290
ఇప్పుడు నేను రెండు విలువలు ప్లగ్ అనుకుంటున్నారా.

1291
01:03:21,290 --> 01:03:24,530
నేను తాత్కాలికంగా ప్రశ్న ఉంచాము
ప్రశ్న ఆహ్వానించడానికి ఉంది సూచిస్తుంది.

1292
01:03:24,530 --> 01:03:29,940
>> నేను తరువాత 65 నుండి iterate మీరు
వర్ణమాల యొక్క 26 అక్షరాలు కోసం,

1293
01:03:29,940 --> 01:03:35,190
ప్రతి పునరావృతం న ముద్రించి ఆ
పాత్ర యొక్క సమగ్ర సమానమైన.

1294
01:03:35,190 --> 01:03:38,299
ఇతర మాటలలో, నేను కావలసిన
పైగా 26 సంఖ్యలు ముద్రణ iterate

1295
01:03:38,299 --> 01:03:41,590
ASCII అక్షరాల ఏమిటి, లేఖ,
మరియు సంబంధిత సంఖ్య మాదిరిగా ఏమి

1296
01:03:41,590 --> 01:03:44,650
నిజంగా కేవలం పునః
స్లయిడ్ నుండి చార్ట్.

1297
01:03:44,650 --> 01:03:47,010
కాబట్టి అయితే ఈ ప్రశ్నార్థకాలుగా ఉండాలి?

1298
01:03:47,010 --> 01:03:51,760
>> సరే, రెండవ హాజరవుతారు
ఒక కేవలం వేరియబుల్ నేను ఉండాలి.

1299
01:03:51,760 --> 01:03:53,860
నేను అనేక ఆ చూడాలనుకుంటే.

1300
01:03:53,860 --> 01:03:58,920
మరియు మధ్య వాదన
ఇక్కడ, నేను కంప్యూటర్ తెలియజేయవచ్చు

1301
01:03:58,920 --> 01:04:03,470
ఆ పూర్ణాంక చికిత్స
నేను ఒక పాత్రగా ఉంటుంది కాబట్టి

1302
01:04:03,470 --> 01:04:05,880
శాతం సి కోసం ఇక్కడ ప్రత్యామ్నాయంగా

1303
01:04:05,880 --> 01:04:07,990
>> ఇతర మాటలలో, నేను,
మానవ ప్రోగ్రామర్, తెలిసిన

1304
01:04:07,990 --> 01:04:09,865
ఈ కేవలం సంఖ్యలు
రోజు చివరిలో.

1305
01:04:09,865 --> 01:04:12,500
నేను 65 తప్పక తెలుసు
కొన్ని పాత్ర మ్యాప్.

1306
01:04:12,500 --> 01:04:15,310
ఈ స్పష్టమైన తారాగణం తో
ఒక కుండలీకరణములలో తో,

1307
01:04:15,310 --> 01:04:18,840
మీకు కావలసిన డేటా రకం పేరు
మార్చుకునేందుకు, మరియు ఒక సంవృత కుండలీకరణములలో

1308
01:04:18,840 --> 01:04:21,200
మీకు చెప్తాను
కంప్యూటర్, హే, కంప్యూటర్,

1309
01:04:21,200 --> 01:04:24,130
ఒక చార్ ఈ పూర్ణాంక మారుస్తాయి.

1310
01:04:24,130 --> 01:04:26,250
>> నేను ఈ అమలు
ప్రోగ్రాం కంపైల్ తర్వాత,

1311
01:04:26,250 --> 01:04:29,740
యొక్క నేను ASCII 0 చేస్తాము పొందుతారు ఏమి చూద్దాం.

1312
01:04:29,740 --> 01:04:33,020
అది రంధ్రాన్ని సరి చేయు, నేను ఇక్కడ ఏమి చేస్తారు?

1313
01:04:33,020 --> 01:04:35,884
అస్పష్టమైన గుర్తింపు,
అన్ని కుడి, కావాలని కాదు,

1314
01:04:35,884 --> 01:04:37,800
కానీ యొక్క చూసేలా ఉంటే మేము కాదు
ఈ ద్వారా కారణం.

1315
01:04:37,800 --> 01:04:41,220
>> కాబట్టి లైన్ నేను రాలేదు five--
చాలా దూరం అప్ screwing ముందు.

1316
01:04:41,220 --> 01:04:42,140
పరవాలేదు.

1317
01:04:42,140 --> 01:04:46,560
నేను లైన్ 5 సమానం 65-- నేను చూడండి.

1318
01:04:46,560 --> 01:04:50,130
కాబట్టి కొన్ని వలె, సి లో గుర్తు
మీరు ముందు ప్రోగ్రామింగ్ కలిగి ఉంటే భాషలు

1319
01:04:50,130 --> 01:04:52,190
అనుభవం, మీరు
కంప్యూటర్ చెప్పడం,

1320
01:04:52,190 --> 01:04:55,040
స్క్రాచ్ కాకుండా, ఏమి
వేరియబుల్ రకం ఇది.

1321
01:04:55,040 --> 01:04:56,860
>> నేను ఇక్కడ ఒక ముఖ్యమైన పదబంధం మర్చిపోయారు.

1322
01:04:56,860 --> 01:04:59,200
లైన్ ఐదు, నేను ఉపయోగించడం ప్రారంభించాను.

1323
01:04:59,200 --> 01:05:01,560
కానీ నేను సి చెప్పారు లేదు
ఏమి డేటా రకం ఇది.

1324
01:05:01,560 --> 01:05:04,570
సో నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు
చెప్పేది అబ్బా, అది ఒక పూర్ణాంకం చేస్తాయి.

1325
01:05:04,570 --> 01:05:07,050
>> ఇప్పుడు నేను ముందుకు వెళ్లి మళ్ళీ కంపైల్ వెళుతున్న.

1326
01:05:07,050 --> 01:05:08,080
ఆ పరిష్కరించబడింది.

1327
01:05:08,080 --> 01:05:12,660
./ascii0 Enter, చల్లని రకంగా.

1328
01:05:12,660 --> 01:05:15,360
అది సూపర్ ఫాస్ట్ ఉంది
కంప్యూటర్ ఈ ప్రశ్న అడగండి

1329
01:05:15,360 --> 01:05:18,885
బదులుగా ఒక స్లయిడ్ లో దానిని చూడటం కంటే
, పంక్తికి ఒకటి ముద్రించిన 65 ఉంది,

1330
01:05:18,885 --> 01:05:24,860
B అప్పటినుండి down-- 66, అన్ని మార్గం
అక్షరాలు z ఈ 26 times-- చేసింది,

1331
01:05:24,860 --> 01:05:25,630
ఇది 90 ఉంది.

1332
01:05:25,630 --> 01:05:27,790
మరియు, నిజానికి, కొద్దిగా
మరింత తెలివైన చేస్తాను

1333
01:05:27,790 --> 01:05:31,030
నాకు ఉన్నాయి ఆధారపడేవారు కాదు
కంప్యూటర్లో 26 జోడించడానికి.

1334
01:05:31,030 --> 01:05:34,060
నేను పూర్తి కాలేదు
90 అలాగే, చాలా కాలం

1335
01:05:34,060 --> 01:05:37,390
నేను రెండుసార్లు అదే తప్పు లేదు.

1336
01:05:37,390 --> 01:05:41,880
నేను గుండా వెళ్లాలనుకుంటే
z, కేవలం వై ద్వారా.

1337
01:05:41,880 --> 01:05:44,000
>> కాబట్టి ఒక స్పష్టమైన తారాగణం వార్తలు.

1338
01:05:44,000 --> 01:05:47,860
ఈ హాజరవుతారు
కూడా అవసరం లేదు.

1339
01:05:47,860 --> 01:05:52,480
నాకు ముందుకు వెళ్లి ఈ తిరిగి లెట్
కంపైలర్, మరియు గణగణమని ASCII 0.

1340
01:05:52,480 --> 01:05:54,940
ఇది సి అందంగా స్మార్ట్ అని హాజరవుతారు.

1341
01:05:54,940 --> 01:05:57,150
>> మరియు printf, ముఖ్యంగా,
చాలా స్మార్ట్ ఉంది.

1342
01:05:57,150 --> 01:06:01,260
మీరు కేవలం రెండుసార్లు ఒక నేను పాస్ ఉంటే
రెండు placeholders, printf

1343
01:06:01,260 --> 01:06:04,510
, గ్రహిస్తారు OH, బాగా నేను మీకు తెలుసా
నాకు ఒక కొన్ని సంఖ్య పూర్ణాంకం కలిగించింది,

1344
01:06:04,510 --> 01:06:06,380
65 లేదా 90 లేదా సంసార వంటి.

1345
01:06:06,380 --> 01:06:10,170
కానీ, నేను మీరు నాకు కావలసిన చూడండి
ఒక పాత్ర వలె ఆ సంఖ్యను ఫార్మాట్.

1346
01:06:10,170 --> 01:06:16,460
కాబట్టి printf పరిపూర్ణంగా తారాగణం
ది అలాగే మీరు ఒక చార్ Int.

1347
01:06:16,460 --> 01:06:19,360
సో అన్ని వద్ద ఒక సమస్య కాదు.

1348
01:06:19,360 --> 01:06:23,100
>> కాని ఈ ఈక్వివాలన్స్ యొక్క, గమనించి
మేము నిజంగా అదే చేయవచ్చు.

1349
01:06:23,100 --> 01:06:26,520
నాకు ముందుకు వెళ్లి ఒక తయారు చేద్దాము
దీన్ని ASCII 1.c. ఇతర వెర్షన్

1350
01:06:26,520 --> 01:06:31,800
మరియు బదులుగా పైగా iterating
పూర్ణ సంఖ్యలు, నిజంగా మీ మనసును రగిలించు చేయవచ్చు

1351
01:06:31,800 --> 01:06:33,610
అక్షరాల కంటే iterating ద్వారా.

1352
01:06:33,610 --> 01:06:37,660
ఒక చార్ సి రాజధాని గెట్స్ ఉంటే, నేను
ముందుకు వెళ్లి ఈ చేయాలనుకుంటున్నారా,

1353
01:06:37,660 --> 01:06:41,740
చాలా కాలం C కంటే తక్కువ లేదా సమానం గా
రాజధాని జడ్ మరియు ప్రతి మళ్ళా న

1354
01:06:41,740 --> 01:06:45,690
నేను సి పెంచడం అనుకుంటున్నారు, నేను
ఇప్పుడు నా printf లైన్ లో ఇక్కడ

1355
01:06:45,690 --> 01:06:51,320
సే, శాతం సి
శాతం నేను మళ్ళీ, కామా సి

1356
01:06:51,320 --> 01:06:57,200
>> మరియు ఇప్పుడు, నేను ఇతర దిశలో వెళ్ళవచ్చు,
నడిపేవారిని పాత్ర కాస్టింగ్

1357
01:06:57,200 --> 01:06:58,500
పూర్ణాంకం.

1358
01:06:58,500 --> 01:07:00,560
సో, మళ్ళీ, ఎందుకు మీరు ఈ చేస్తారు?

1359
01:07:00,560 --> 01:07:03,830
ఇది యొక్క క్రమం కొద్దిగా అదృష్టము వార్తలు
అక్షరాలు పరంగా చేర్చుకోవడం.

1360
01:07:03,830 --> 01:07:07,430
>> కానీ మీరు ఏమి అర్థం ఉంటే
హుడ్ కింద జరగబోతోంది,

1361
01:07:07,430 --> 01:07:08,430
ఎలాంటి మాయాజాలం నిజంగా ఉంది.

1362
01:07:08,430 --> 01:07:13,060
మీరు కేవలం hey, కంప్యూటర్ ఇవ్వాలని, చెబుతున్న
నాకు ఒక వేరియబుల్ రకం చార్ సి అని.

1363
01:07:13,060 --> 01:07:16,520
రాజధాని A. దాన్ని ప్రారంభించును మరియు
సింగిల్ కోట్స్ విషయం గమనించవచ్చు.

1364
01:07:16,520 --> 01:07:19,580
>> సి లో పాత్రలకు నుండి గుర్తుకు
గత వారం, మీరు సింగిల్ కోట్స్ ఉపయోగించడానికి.

1365
01:07:19,580 --> 01:07:23,720
తీగల పదాలతో
మాటలను, మీరు డబుల్ కోట్స్ ఉపయోగించడానికి.

1366
01:07:23,720 --> 01:07:27,210
సరే, కంప్యూటర్, కాబట్టి ఈ పనిని,
పాత్ర కాలం కంటే తక్కువ

1367
01:07:27,210 --> 01:07:28,050
లేదా z సమానం.

1368
01:07:28,050 --> 01:07:32,640
నేను నా ASCII టేబుల్ నుండి తెలిసిన అన్ని
ఈ ASCII సంకేతాలు ఆనుకొని ఉన్నాయి.

1369
01:07:32,640 --> 01:07:33,400
>> ఏ అంతరాలను ఉంది.

1370
01:07:33,400 --> 01:07:36,737
కనుక ఇది కేవలం ఒక Z ద్వారా వార్తలు,
ఒక సంఖ్య ప్రతి వేరు.

1371
01:07:36,737 --> 01:07:38,820
ఆపై నేను పెంచడం చేయవచ్చు
ఒక చార్, నేను నిజంగా అనుకుంటే.

1372
01:07:38,820 --> 01:07:40,390
రోజు చివరిలో,
అది కేవలం ఒక సంఖ్య.

1373
01:07:40,390 --> 01:07:41,030
ఇది నాకు తెలుసు.

1374
01:07:41,030 --> 01:07:43,670
సో నేను దానికి 1 జోడించడానికి భావించడం చేయవచ్చు.

1375
01:07:43,670 --> 01:07:46,940
>> ఆపై ఈ సమయంలో, నేను సి ప్రింట్
ఆపై సమగ్ర సమానమైన.

1376
01:07:46,940 --> 01:07:50,170
ద్విజులు స్పష్టమైన తారాగణం అవసరం లేదు.

1377
01:07:50,170 --> 01:07:52,680
నేను printf వీలు
కంప్యూటర్ ఫిగర్ విషయాలను,

1378
01:07:52,680 --> 01:07:57,300
కాబట్టి ఇప్పుడు నేను అమలు చేస్తే
Ascii1./ascii1, తయారు

1379
01:07:57,300 --> 01:08:01,520
నేను అలాగే ఖచ్చితమైన ఇదే పొందడానికి.

1380
01:08:01,520 --> 01:08:04,530
>> పనికిరాని కార్యక్రమం, ఎవరూ, అయితే
నిజానికి సాఫ్ట్వేర్ వ్రాయడానికి అన్నారు

1381
01:08:04,530 --> 01:08:07,549
దొరుకుతుందని క్రమంలో, ఏమిటి
Z B A పటాలను ఆ సంఖ్య, లేదా, లేక?

1382
01:08:07,549 --> 01:08:10,340
మీరు కేవలం అది గూగుల్ చూడాలని, లేదా
దానిని చూసి ఆన్లైన్, లేదా అది వెతుక్కోవాల్సిన

1383
01:08:10,340 --> 01:08:11,650
ఒక స్లయిడ్, లేదా ఇష్టం.

1384
01:08:11,650 --> 01:08:13,520
సో ఇక్కడ ఈ నిజానికి ఉపయోగకరంగా పొందండి లేదు?

1385
01:08:13,520 --> 01:08:15,960
>> బాగా, ఆ మాట్లాడే
స్లయిడ్, ఉంది గమనించవచ్చు

1386
01:08:15,960 --> 01:08:20,890
పెద్దబడి మధ్య ఇక్కడ ఒక వాస్తవ నమూనా
మరియు ఆ యాదృచ్ఛికం అని చిన్నబడి.

1387
01:08:20,890 --> 01:08:23,760
రాజధాని అని 65 గమనించండి.

1388
01:08:23,760 --> 01:08:25,830
చిన్న ఒక 97 ఉంది.

1389
01:08:25,830 --> 01:08:29,649
మరియు ఎలా దూరంగా తక్కువ సందర్భంలో?

1390
01:08:29,649 --> 01:08:32,649
>> కాబట్టి 65 97 నుండి ఎన్ని దశలను దూరంగా ఉంది?

1391
01:08:32,649 --> 01:08:36,210
కాబట్టి 97 మైనస్ 65 32 ఉంది.

1392
01:08:36,210 --> 01:08:37,910
కాబట్టి రాజధాని ఒక 65 ఉంది.

1393
01:08:37,910 --> 01:08:39,939
మీరు ఆ 32 జోడిస్తే,
మీరు ఒక చిన్న పొందండి.

1394
01:08:39,939 --> 01:08:43,729
మరియు, సమానమైన, మీరు 32 వ్యవకలనం ఉంటే,
మీరు B అదే రాజధానికి తిరిగి పొందడానికి ఫంక్షన్

1395
01:08:43,729 --> 01:08:46,380
చిన్న బి, కొద్దిగా సి బిగ్ సి.

1396
01:08:46,380 --> 01:08:50,670
>> ఈ అంతరాలను మొత్తం 32 దూరంగా ఉన్నాయి.

1397
01:08:50,670 --> 01:08:54,450
ఇప్పుడు, ఈ మమ్మల్ని అనుమతించడం అగుపిస్తుంది
మైక్రోసాఫ్ట్ వర్డ్ వంటి ఏదో,

1398
01:08:54,450 --> 01:08:57,729
లేదా Google డాక్స్, ఇక్కడ మీరు చూపించిన
ప్రతిదీ ఎంచుకోండి మరియు అప్పుడు చెప్పడానికి,

1399
01:08:57,729 --> 01:09:00,520
చిన్నబడి అన్ని మార్చడానికి, లేదా
ఎగువ కేసు అన్ని మార్చడానికి,

1400
01:09:00,520 --> 01:09:03,840
లేదా మొదటి పదం మార్పు
అప్పర్ కేస్ శిక్ష.

1401
01:09:03,840 --> 01:09:07,390
మేము నిజానికి ఏదో ఒకటి చెయ్యాలి
మమ్మల్ని ఆ ఇష్టం.

1402
01:09:07,390 --> 01:09:12,645
>> నాకు ముందుకు వెళ్లి ఒక ఫైల్ సేవ్
ఇక్కడ 0.c. చూపడంలో అని

1403
01:09:12,645 --> 01:09:15,770
యొక్క ముందుకు వెళ్లి ఒక కార్యక్రమం అప్ రెచ్చిపోయినప్పుడు తెలియజేయండి
సరిగ్గా ఈ కింది విధంగా ఆ చేస్తుంది.

1404
01:09:15,770 --> 01:09:18,460
కాబట్టి CS50 లైబ్రరీ ఉన్నాయి.

1405
01:09:18,460 --> 01:09:21,430
మరియు ప్రామాణిక I / O ఉన్నాయి.

1406
01:09:21,430 --> 01:09:22,787
>> నేను ఈ త్వరలోనే తెలుసు.

1407
01:09:22,787 --> 01:09:24,870
కాబట్టి నేను అది చాలు వెళుతున్న
ఇప్పటికే, string.h,

1408
01:09:24,870 --> 01:09:26,960
నేను యాక్సెస్
స్టిర్లింగ్ వంటి విషయాలు,

1409
01:09:26,960 --> 01:09:29,620
ఆ తరువాత యధావిధిగా, ప్రధాన గర్జన Int.

1410
01:09:29,620 --> 01:09:33,420
ఆపై నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు స్ట్రింగ్ పొందండి గెట్స్ తీగలను చేయండి,

1411
01:09:33,420 --> 01:09:35,032
కేవలం యూజర్ నుండి ఒక స్ట్రింగ్ పొందండి.

1412
01:09:35,032 --> 01:09:36,740
ఆపై నేను వెళుతున్న
నా తెలివి తనిఖీ.

1413
01:09:36,740 --> 01:09:40,510
స్ట్రింగ్ సమాన శూన్య కాకపోతే,
అప్పుడు అది ముందుకు భద్రంగా ఉంది.

1414
01:09:40,510 --> 01:09:42,000
నేను ఏమి అనుకుంటున్నారు?

1415
01:09:42,000 --> 01:09:48,700
నేను, నేను నుండి 0 సమానం iterate వెళుతున్న
మరియు n s యొక్క స్ట్రింగ్ పొడవు.

1416
01:09:48,700 --> 01:09:51,899
>> నేను చాలా కాలం ఈ చేయ బోతున్నాను
నేను ప్లస్ ప్లస్ n కంటే తక్కువ, మరియు.

1417
01:09:51,899 --> 01:09:55,060
ఇప్పటివరకు, నేను నిజంగా కేవలం ఉన్నాను
యెదుటనుండి ఆలోచనలను అప్పు.

1418
01:09:55,060 --> 01:09:57,010
ఇప్పుడు నేను ఒక శాఖ పరిచయం వెళుతున్న.

1419
01:09:57,010 --> 01:09:59,635
>> సో స్క్రాచ్ పేరు తిరిగి అనుకుంటున్నాను
మేము రోడ్ లో ఆ ఫోర్కులు కలిగి,

1420
01:09:59,635 --> 01:10:05,110
మరియు గత వారం C. లో నేను వెళుతున్న
చెపుతాను, స్ i-th పాత్ర

1421
01:10:05,110 --> 01:10:09,250
కంటే ఎక్కువ లేదా
కేసు తగ్గుతాయని సమాన,

1422
01:10:09,250 --> 01:10:13,340
and-- స్క్రాచ్ లో మీరు వాచ్యంగా చేస్తాను
మరియు, కానీ సి లో మీరు ఏంపర్సెండ్ చెప్పటానికి,

1423
01:10:13,340 --> 01:10:19,830
ampersand-- మరియు s i-th పాత్ర
కంటే తక్కువ లేదా కేసు z తగ్గుతాయని సమానం

1424
01:10:19,830 --> 01:10:21,780
ఇంట్రెస్టింగ్ ఏదో ఒకటి చూద్దాం.

1425
01:10:21,780 --> 01:10:27,020
యొక్క నిజానికి ప్రింట్ ఒక లెట్
ఏ న్యూ లైన్ తో పాత్ర

1426
01:10:27,020 --> 01:10:31,760
ఆ స్ట్రింగ్ లో పాత్ర,
స్ట్రింగ్ లో i-th పాత్ర.

1427
01:10:31,760 --> 01:10:37,420
>> కానీ యొక్క ముందుకు వెళ్లి
దాని నుండి 32 వ్యవకలనం.

1428
01:10:37,420 --> 01:10:42,120
ఎల్స్ ఉంటే పాత్ర
మేము వెతికే స్ట్రింగ్

1429
01:10:42,120 --> 01:10:45,950
చిన్న మధ్యే కాదు
మరియు చిన్న z, ముందుకు వెళ్ళి

1430
01:10:45,950 --> 01:10:48,610
మరియు కేవలం దాన్ని మారకుండా ముద్రించబడింది.

1431
01:10:48,610 --> 01:10:50,840
కాబట్టి మేము పరిచయం చేసాము
ఈ bracketed సంజ్ఞామానం

1432
01:10:50,840 --> 01:10:53,560
వద్ద పొందడానికి మా తీగలను కోసం
నేను-వ స్ట్రింగ్ లో పాత్ర.

1433
01:10:53,560 --> 01:10:57,520
>> నేను వంటి, కొన్ని నియత తర్కం జోడించిన
గత వారం యొక్క వారం ఒకటి, ఇక్కడ మొదటి

1434
01:10:57,520 --> 01:10:59,880
నేను నా ప్రాథమిక ఉపయోగించి వెబ్
ఏది అవగాహన

1435
01:10:59,880 --> 01:11:01,130
హుడ్ కింద జరగబోతోంది.

1436
01:11:01,130 --> 01:11:04,190
యొక్క i-th పాత్ర
ఒక కంటే ఎక్కువ లేదా సమాన?

1437
01:11:04,190 --> 01:11:08,290
వలె, ఇది 97, లేదా 98 ఉంది,
లేదా 99, మొదలగునవి?

1438
01:11:08,290 --> 01:11:11,940
>> కానీ అది కూడా తక్కువ లేదా సమానం
చిన్న z విలువకు?

1439
01:11:11,940 --> 01:11:16,210
మరియు అలా అయితే, ఈ లైన్ అర్థం ఏమిటి?

1440
01:11:16,210 --> 01:11:20,250
14, ఈ విధమైన ఉంది
మొత్తం ఆలోచన యొక్క బీజ,

1441
01:11:20,250 --> 01:11:23,840
తన లేఖలో చూపడంలో
కేవలం దాని నుండి 32 తీసివేయడం,

1442
01:11:23,840 --> 01:11:29,370
ఈ సందర్భంలో, నేను తెలుసు ఎందుకంటే, ఆ ప్రకారం
చార్ట్ ఎలా నా సంఖ్యలు ప్రాతినిధ్యం వహిస్తున్నారు.

1443
01:11:29,370 --> 01:11:33,925
కాబట్టి యొక్క ముందుకు వెళ్లి ఈ అమలు అనుమతిస్తాయి,
0.c చూపడంలో కంపైల్ తర్వాత,

1444
01:11:33,925 --> 01:11:36,210
మరియు రన్ చూపడంలో 0.

1445
01:11:36,210 --> 01:11:40,300
>> యొక్క లాగ టైప్ లెట్
అన్ని చిన్న లో, Zamyla ఎంటర్.

1446
01:11:40,300 --> 01:11:42,780
ఇప్పుడు మేము అన్ని పెద్ద Zamyla ఉన్నాయి.

1447
01:11:42,780 --> 01:11:45,050
యొక్క అన్ని చిన్న లో రాబ్ లో టైప్ లెట్.

1448
01:11:45,050 --> 01:11:46,674
యొక్క అన్ని చిన్న లో జాసన్ ప్రయత్నించండి లెట్.

1449
01:11:46,674 --> 01:11:48,590
మరియు మేము తరచుగా వస్తున్నట్లయితే
బలవంతంగా క్యాపిటలైజేషన్.

1450
01:11:48,590 --> 01:11:50,960
ఒక చిన్న బగ్ ఉందని నేను
రకమైన ముందుగా లేదు.

1451
01:11:50,960 --> 01:11:54,050
నా కొత్త ప్రాంప్ట్ ముగించాడు గమనించవచ్చు
వారి పేర్లు అదే లైన్ లో,

1452
01:11:54,050 --> 01:11:55,520
ఇది ఒక చిన్న దారుణంగా అనిపిస్తుంది.

1453
01:11:55,520 --> 01:11:59,170
>> నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు
నిజానికి ఈ కార్యక్రమం చివరిలో

1454
01:11:59,170 --> 01:12:02,110
ఒక NEWLINE పాత్రను ప్రింట్.

1455
01:12:02,110 --> 01:12:03,160
అంతే.

1456
01:12:03,160 --> 01:12:06,120
printf తో, మీరు అవసరం లేదు
చరరాశులు లేదా ఫార్మాట్ కోడ్ పాస్.

1457
01:12:06,120 --> 01:12:08,460
మీరు వాచ్యంగా కేవలం ముద్రించవచ్చు
ఒక NEWLINE అలాంటిదే.

1458
01:12:08,460 --> 01:12:13,529
>> కాబట్టి యొక్క ముందుకు వెళ్లి తయారు చేద్దాము
మళ్ళీ చూపడంలో 0, అయినప్పుడు తిరిగి, Zamyla.

1459
01:12:13,529 --> 01:12:14,820
ఇప్పుడు అది కొద్దిగా prettier ఉంది.

1460
01:12:14,820 --> 01:12:17,274
ఇప్పుడు, నా ప్రాంప్ట్ తన సొంత కొత్త లైన్ ఉంది.

1461
01:12:17,274 --> 01:12:18,440
కాబట్టి అన్ని జరిమానా మరియు మంచి.

1462
01:12:18,440 --> 01:12:19,910
కాబట్టి ఒక మంచి ఉదాహరణ.

1463
01:12:19,910 --> 01:12:22,700
కానీ నేను కూడా తప్పనిసరిగా లేదు
హార్డ్ కోడ్ 32 అవసరం.

1464
01:12:22,700 --> 01:12:23,350
నీకు తెలుసా?

1465
01:12:23,350 --> 01:12:26,350
నేను అలా చెప్పడానికి కాలేదు
తేడా ఏమిటి గుర్తుంచుకోవాలి.

1466
01:12:26,350 --> 01:12:29,330
>> కానీ నాకు తెలుసు ఉంటే నేను
తక్కువ కేసు లేఖ,

1467
01:12:29,330 --> 01:12:34,430
నేను తప్పనిసరిగా వ్యవకలనం కావలసిన
సంసార దూరం చిన్న మధ్య

1468
01:12:34,430 --> 01:12:39,160
ఒక పెద్ద ఒక, నేను భావించేందుకు ఉంటే ఎందుకంటే
ఇతర అక్షరాల అన్ని ఒకటే

1469
01:12:39,160 --> 01:12:41,045
ఆ పని ఉద్యోగం పొందాలి.

1470
01:12:41,045 --> 01:12:42,670
కానీ అలా కాకుండా, మీరు ఏమి?

1471
01:12:42,670 --> 01:12:44,240
ఇప్పటికీ మరొక విధంగా ఉన్నాయి.

1472
01:12:44,240 --> 01:12:48,090
>> నేను ఉన్నట్లయితే ఆ 1.c-- చూపడంలో చెయ్యబడితే
ఒక ప్రత్యేక ఫైలు లోకి ఉంచాలి.

1473
01:12:48,090 --> 01:12:51,030
యొక్క ఈ క్రింది విధంగా 2.c చూపడంలో తెలియజేసేలా.

1474
01:12:51,030 --> 01:12:53,060
నేనిక్కడ ఈ శుభ్రం చేయడానికి వెళుతున్న.

1475
01:12:53,060 --> 01:12:57,420
మరియు బదులుగా కూడా కలిగి
తెలిసిన లేదా ఆ తక్కువ స్థాయి పట్టించుకోనట్లు

1476
01:12:57,420 --> 01:13:01,090
అమలు వివరాలు, నేను బదులుగా రెడీ
కేవలం ఒక పాత్ర ప్రింట్ అన్నారు

1477
01:13:01,090 --> 01:13:04,610
కోట్ unquote, శాతం సి, మరియు
అప్పుడు మరొక ఫంక్షన్ కాల్

1478
01:13:04,610 --> 01:13:09,950
ఒక వాదన పడుతుంది ఉనికిలో ఉంది,
ఒక పాత్ర, ఈ వంటిది.

1479
01:13:09,950 --> 01:13:12,630
>> ఇది ఉంది, సి హాజరవుతారు
మరొక ఫంక్షన్ కాల్

1480
01:13:12,630 --> 01:13:15,550
, ఎగువ ఇది దాని పేరు
సూచిస్తుంది ఒక పాత్ర పడుతుంది

1481
01:13:15,550 --> 01:13:19,350
మరియు దాని ఎగువ కేసు చేస్తుంది
సమానమైన, మరియు అప్పుడు అది తిరిగి

1482
01:13:19,350 --> 01:13:21,410
కాబట్టి printf అని అక్కడ ప్రదర్శించాడు చేయవచ్చు.

1483
01:13:21,410 --> 01:13:25,484
అందువలన అయితే, దీన్ని నేను
మరొక ఫైల్ పరిచయం అవసరం.

1484
01:13:25,484 --> 01:13:28,400
మరొక ఫైల్ ఉంది బయటకు ఇది మారుతుంది
మీరు మాత్రమే తరగతి నుండి తెలుసు అని,

1485
01:13:28,400 --> 01:13:33,020
ఒక పాఠ్య పుస్తకం, లేదా ఒక ఆన్లైన్ లేదా
సూచన, సి type.h. అని

1486
01:13:33,020 --> 01:13:38,570
>> నా శీర్షిక మధ్య వరకు జోడించవచ్చు చేస్తే
ఫైళ్లు, మరియు ఇప్పుడు తిరిగి కంపైల్ ఈ కార్యక్రమం

1487
01:13:38,570 --> 01:13:43,040
capitalize2, ఎంటర్ ./capitalize2.

1488
01:13:43,040 --> 01:13:46,690
యొక్క అన్ని లో, Zamyla టైప్ లెట్
చిన్న, ఇప్పటికీ అదే పనిచేస్తుంది.

1489
01:13:46,690 --> 01:13:48,040
కానీ మీరు ఏమి?

1490
01:13:48,040 --> 01:13:55,590
ఇది ఎగువ కు హాజరవుతారు
కొన్ని ఇతర కార్యాచరణను కలిగి ఉంది.

1491
01:13:55,590 --> 01:13:58,410
>> మరియు నాకు ఈ పరిచయం తెలియజేయండి
వికారంగా విధమైన, ఇక్కడ ఆదేశం

1492
01:13:58,410 --> 01:14:00,250
ప్రకటించుకున్నాడు, అయితే మాన్యువల్ మనిషి.

1493
01:14:00,250 --> 01:14:03,960
ఇది ఆ చాలా Linux కంప్యూటర్లలో అవుతుంది
మనం లినక్స్ ఆపరేటింగ్ ఇక్కడ ఉపయోగిస్తున్నారు వంటి

1494
01:14:03,960 --> 01:14:06,270
ఒక ఆదేశాన్ని సిస్టమ్
చెప్పారు ఇది వ్యక్తి అని,

1495
01:14:06,270 --> 01:14:08,530
హే, కంప్యూటర్, నాకు ఇవ్వండి
కంప్యూటర్ యొక్క మాన్యువల్.

1496
01:14:08,530 --> 01:14:10,680
మీరు ఏమి అనుకుంటున్నారు
మాన్యువల్ వెతకండి?

1497
01:14:10,680 --> 01:14:13,840
>> నేను ఫంక్షన్ చూసేందుకు కావలసిన
ఎగువ అని నమోదు చేయండి.

1498
01:14:13,840 --> 01:14:16,070
మరియు అది ఒక చిన్న గుప్తమైన
కొన్నిసార్లు చదవడానికి.

1499
01:14:16,070 --> 01:14:18,780
కానీ మేము ఉన్నాము గమనించవచ్చు
లినక్స్ ప్రోగ్రామర్ యొక్క మాన్యువల్.

1500
01:14:18,780 --> 01:14:19,530
మరియు అది అన్ని టెక్స్ట్ యొక్క.

1501
01:14:19,530 --> 01:14:21,905
మరియు అక్కడ గమనిస్తారు
ఇక్కడ ఫంక్షన్ యొక్క పేరు.

1502
01:14:21,905 --> 01:14:25,030
ఇది అనే బంధువు ఉంది హాజరవుతారు
వ్యతిరేక లేదు ఇది తగ్గించటం జరిగింది.

1503
01:14:25,030 --> 01:14:29,710
మరియు సంగ్రహం క్రింద నోటీసు, ఈ ఉపయోగించడానికి
మాట్లాడటానికి, man పేజీ పని,

1504
01:14:29,710 --> 01:14:32,220
నాకు నేను చెబుతున్నది
సి type.h. ఉన్నాయి అవసరం

1505
01:14:32,220 --> 01:14:33,630
మరియు నేను ఆచరణలో నుండి తెలుసు.

1506
01:14:33,630 --> 01:14:36,210
>> ఇక్కడ, అది నాకు రెండు చూపుతోందని
ఫంక్షన్ కోసం నమూనా,

1507
01:14:36,210 --> 01:14:39,070
కాబట్టి నేను ఎప్పుడూ ఈ ఉపయోగించడానికి కావాలా
నేను వారు ఇన్పుట్గా తీసుకుని ఏమి తెలుసు,

1508
01:14:39,070 --> 01:14:40,652
మరియు వారు అవుట్పుట్ తిరిగి ఏమిటి.

1509
01:14:40,652 --> 01:14:42,360
ఆపై నేను చదివితే
వివరణ, నేను చూడండి

1510
01:14:42,360 --> 01:14:44,820
మరింత వివరంగా ఫంక్షన్ ఏమి.

1511
01:14:44,820 --> 01:14:48,100
మరింత ముఖ్యంగా, ఉంటే
నేను తిరిగి విలువ క్రింద చూడండి,

1512
01:14:48,100 --> 01:14:51,710
అది తిరిగి విలువ చెప్పారు
మార్పిడి లేఖ ఆ,

1513
01:14:51,710 --> 01:14:57,880
లేదా C అసలు ఇన్పుట్ ఉంటే
మార్పిడి సాధ్యం కాదు.

1514
01:14:57,880 --> 01:15:01,992
>> ఇతర మాటలలో, ఎగువ ప్రయత్నించండి చేస్తాము
అప్పర్ కేస్ ఒక లేఖ మార్చేందుకు.

1515
01:15:01,992 --> 01:15:03,450
మరియు అలా అయితే, అది తిరిగి వెళుతున్న.

1516
01:15:03,450 --> 01:15:07,010
కానీ కొన్ని కారణం అది పోతే
బహుశా ఇది ఇప్పటికే ఎగువ కేస్,

1517
01:15:07,010 --> 01:15:09,550
దీనికి ఆశ్చర్యార్థకం పాయింట్
లేదా కొన్ని ఇతర punctuation--

1518
01:15:09,550 --> 01:15:12,200
అది కేవలం జరగబోతోంది
యదార్థ C తిరిగి,

1519
01:15:12,200 --> 01:15:17,340
ఇది నేను నా కోడ్ చేయవచ్చు అర్థం
మంచి క్రింది విధంగా రూపొందించబడింది.

1520
01:15:17,340 --> 01:15:20,580
>> నేను అన్ని అవసరం లేదు
కోడ్ యొక్క ఈ రంధ్రాన్ని సరి చేయు పంక్తులు.

1521
01:15:20,580 --> 01:15:22,610
నేను చేసిన రేఖల అన్ని
కేవలం హైలైట్ చెయ్యవచ్చు

1522
01:15:22,610 --> 01:15:28,700
కేవలం ఒక సాధారణ కూలిపోయింది
దీన్ని printf శాతం ఇది లైన్,

1523
01:15:28,700 --> 01:15:33,510
ఎగువ ఎస్ బ్రాకెట్ నేను సి.

1524
01:15:33,510 --> 01:15:36,090
మరియు ఈ ఒక ఉంటుంది
మంచి డిజైన్ యొక్క ఉదాహరణకు.

1525
01:15:36,090 --> 01:15:40,040
>> ఎందుకు 7 లేదా 8 పంక్తులు అమలు
కోడ్ యొక్క, సంసార నేను కేవలం ఉంది

1526
01:15:40,040 --> 01:15:44,960
మీరు బదులుగా కూలిపోతుంది ఉన్నప్పుడు, తొలగించిన
తర్కానికి మరియు నిర్ణయం తీసుకోవటంలో అన్ని

1527
01:15:44,960 --> 01:15:49,620
ఒక్క లైన్, 13 ఇప్పుడు ఆ
ఒక లైబ్రరీ ఆధారపడుతుంది ఫంక్షన్

1528
01:15:49,620 --> 01:15:53,430
C తో పాటు వచ్చే ఒక విధి, కానీ ఆ
మీరు దీన్ని ఖచ్చితంగా ఏమి చేస్తుంది.

1529
01:15:53,430 --> 01:15:55,295
మరియు, స్పష్టముగా, కూడా
అది సి తో రాలేదు,

1530
01:15:55,295 --> 01:15:58,880
మీరు మీరుగా అమలు అవకాశమున్నందున,
మేము పొందుటకు ప్రతికూల Int తో చూసిన

1531
01:15:58,880 --> 01:16:01,700
మరియు అలాగే అనుకూల Int గత వారం పొందండి.

1532
01:16:01,700 --> 01:16:03,470
>> ఈ కోడ్ ఇప్పుడు చాలా చదవదగ్గ.

1533
01:16:03,470 --> 01:16:06,670
మరియు, నిజానికి, మేము అప్ స్క్రోల్ చేయండి,
ఎంత ఎక్కువ కాంపాక్ట్ చూడండి

1534
01:16:06,670 --> 01:16:08,360
నా కార్యక్రమం ఈ వెర్షన్.

1535
01:16:08,360 --> 01:16:11,230
అది ఇప్పుడు చిన్న టాప్ హెవీ,
ఈ కలిగి తో.

1536
01:16:11,230 --> 01:16:14,380
కానీ ఇప్పుడు నేను నిలబడి నేను ఎందుకంటే సరే
ప్రోగ్రామర్లు భుజాల మీద

1537
01:16:14,380 --> 01:16:15,300
నా ముందు.

1538
01:16:15,300 --> 01:16:18,440
మరియు అది ఎవరైతే అయిన
నిజంగా ఉన్నత అమలు

1539
01:16:18,440 --> 01:16:21,470
చాలా వంటి నాకు అనుకూలంగా ఎవరైతే అతడ్ని
అమలు స్టిర్లింగ్ నిజంగా

1540
01:16:21,470 --> 01:16:24,790
కొంతకాలం క్రితం నాకు ఒక అనుకూలంగా లేదు.

1541
01:16:24,790 --> 01:16:26,970
కాబట్టి ఇప్పుడు మేము ఒక కలిగి
మంచి డిజైన్ ప్రోగ్రామ్

1542
01:16:26,970 --> 01:16:31,680
ఖచ్చితమైన అదే తర్కం అమలు.

1543
01:16:31,680 --> 01:16:35,580
>> స్టిర్లింగ్ మాట్లాడుతూ, వీలు
నాకు ముందుకు వెళ్లి ఇలా.

1544
01:16:35,580 --> 01:16:38,320
నాకు ముందుకు వెళ్లి సేవ్ చేసేలా
ఈ ఫైలు stirling.c వంటి.

1545
01:16:38,320 --> 01:16:43,255
మరియు అది అవుతుంది, మేము తిరిగి రాలిపోవడం చేయవచ్చు
అందంగా కేవలం ఇప్పుడు మరొక పొర.

1546
01:16:43,255 --> 01:16:45,630
నేను ముందుకు విప్ వెళ్ళి వెళుతున్న
ప్రధాన మరొక కార్యక్రమం

1547
01:16:45,630 --> 01:16:49,759
ఇక్కడ కేవలం తిరిగి అమలుచేసే
ఈ క్రింది విధంగా స్ట్రింగ్ పొడవు.

1548
01:16:49,759 --> 01:16:52,300
కాబట్టి ఇక్కడ కోడ్ ఒక లైన్ అని
నాకు వినియోగదారు నుండి ఒక స్ట్రింగ్ గెట్స్.

1549
01:16:52,300 --> 01:16:53,910
మేము మళ్ళీ మళ్ళీ ఈ ఉపయోగించి ఉన్నాను.

1550
01:16:53,910 --> 01:16:58,900
నాకు నేనే ఒక వేరియబుల్ అని ఇవ్వాలని లెట్
అనేక నిల్వ రకం Int n.

1551
01:16:58,900 --> 01:17:02,490
>> మరియు నాకు ముందుకు వెళ్లి
క్రింది తర్కం.

1552
01:17:02,490 --> 01:17:15,610
లు n-th పాత్ర ఉన్నప్పటికీ
సమాన బాక్ స్లాష్ 0, ముందుకు వెళ్ళి

1553
01:17:15,610 --> 01:17:17,930
మరియు n పెంచుతాయి.

1554
01:17:17,930 --> 01:17:23,506
ఆపై printf శాతం నేను n ప్రింట్.

1555
01:17:23,506 --> 01:17:29,200
నేను ఇక్కడ ఈ కార్యక్రమం క్లెయిమ్,
స్ట్రింగ్ పొడవు కాల్ లేకుండా,

1556
01:17:29,200 --> 01:17:31,150
ఒక స్ట్రింగ్ యొక్క పొడవు సంఖ్యలు.

1557
01:17:31,150 --> 01:17:34,600
>> మరియు మేజిక్ పూర్తిగా
లైన్ 8 లో కప్పబడుతుంది

1558
01:17:34,600 --> 01:17:39,830
కొత్త వాక్యనిర్మాణం కనిపిస్తుంది ఏమి తో ఇక్కడ,
ఈ బాక్ స్లాష్ 0 సింగిల్ కోట్స్ లో.

1559
01:17:39,830 --> 01:17:41,360
కాని ఎందుకు అని?

1560
01:17:41,360 --> 01:17:44,100
బాగా, అయ్యింది ఏమి పరిగణలోకి
అన్ని ఈ సమయంలో జరగబోతోంది.

1561
01:17:44,100 --> 01:17:47,990
>> మరియు జనాంతికంగా నేను మర్చిపోతే ముందు, తెలుసుకోవటం
చాలా, ఆ వ్యక్తి పేజీల పాటు

1562
01:17:47,990 --> 01:17:50,920
ఒక విలక్షణ తో వస్తాయి
CS50 IDE వంటి లైనక్స్ సిస్టమ్,

1563
01:17:50,920 --> 01:17:53,770
తెలుసుకుంటారు మేము
కోర్సు యొక్క సిబ్బంది, కూడా

1564
01:17:53,770 --> 01:17:56,030
ఒక వెబ్సైట్ వెర్షన్ చేసిన
అని ఈ అదే ఆలోచన

1565
01:17:56,030 --> 01:17:59,940
కలిగిన reference.cs50.net,
ఆ అదే మనిషి పేజీల అన్ని

1566
01:17:59,940 --> 01:18:02,020
అదే అన్ని
డాక్యుమెంటేషన్, అలాగే

1567
01:18:02,020 --> 01:18:05,730
అనుమతించే ఎగువన ఒక చిన్న బాక్స్
మీరు బొత్తిగా అన్ని మార్చేందుకు

1568
01:18:05,730 --> 01:18:09,025
తక్కువ సౌకర్యవంతమైన లోకి మర్మమైన భాష
మోడ్, మేము, బోధన సిబ్బంది,

1569
01:18:09,025 --> 01:18:12,150
ద్వారా పోయిందో మరియు సరళీకృతం చేయడానికి ప్రయత్నించారు
విషయాలను భాషపై కొంత

1570
01:18:12,150 --> 01:18:14,830
ఆలోచనల మీద దృష్టి, మరియు
technicalities కొన్ని.

1571
01:18:14,830 --> 01:18:20,070
సో గుర్తుంచుకోండి, reference.cs50.net
అదే విధంగా మరో వనరుగా.

1572
01:18:20,070 --> 01:18:23,800
>> కానీ ఎందుకు స్ట్రింగ్ పొడవు పని చేస్తుంది
నేను ఒక క్షణం క్రితం ప్రతిపాదించారు మార్గం?

1573
01:18:23,800 --> 01:18:25,160
ఇక్కడ Zamyla యొక్క పేరు తిరిగి ఉంది.

1574
01:18:25,160 --> 01:18:27,690
మరియు ఇక్కడ, Zamyla యొక్క పేరు
నేను చేస్తున్న ఉంచేందుకు వంటి, లో బాక్స్,

1575
01:18:27,690 --> 01:18:31,360
ఇది అనే ఒక చిత్రాన్ని చిత్రించటానికి
నిజంగా, కేవలం అక్షరాలు క్రమం.

1576
01:18:31,360 --> 01:18:34,260
కానీ, Zamyla ఉనికిలో లేదు
ఒక కార్యక్రమంలో ఒంటరిగా.

1577
01:18:34,260 --> 01:18:37,420
>> మీరు వ్రాయడానికి మరియు ఒక అమలు చేసేటప్పుడు,
మీరు మీ Mac లేదా మీ PC ఉపయోగించి చేస్తున్నారు

1578
01:18:37,420 --> 01:18:40,010
మెమొరీ లేదా RAM అని మాట్లాడటానికి.

1579
01:18:40,010 --> 01:18:42,620
మరియు మీరు ఆలోచించవచ్చు
కలిగి గా మీ కంప్యూటర్

1580
01:18:42,620 --> 01:18:44,730
మెమరీ గిగాబైట్ల ఈ రోజుల్లో మా.

1581
01:18:44,730 --> 01:18:47,700
మరియు ఒక గిగ్ బిలియన్ల అంటే,
బైట్లు కనుక బిలియన్ల.

1582
01:18:47,700 --> 01:18:48,910
>> కానీ యొక్క సమయం లో రివైండ్ తెలియజేయండి.

1583
01:18:48,910 --> 01:18:51,530
మరియు మేము ఆ ఉపయోగిస్తున్నారు అనుకుందాం
ఒక నిజంగా పాత కంప్యూటర్

1584
01:18:51,530 --> 01:18:55,150
ఓన్లీ మెమరీ 32 బైట్లు ఉంది.

1585
01:18:55,150 --> 01:18:59,310
నేను అనుకొనుట, నా కంప్యూటర్ తెరపై,
ఈ క్రింది విధంగా కేవలం ఈ అవ్ట్ డ్రా.

1586
01:18:59,310 --> 01:19:05,240
>> నేను కేవలం ఆ చెప్పగల్గినవి నా
కంప్యూటర్ ఈ మెమరీ అన్ని ఉంది.

1587
01:19:05,240 --> 01:19:08,830
మరియు ఈ ఉంటే, మెమరీ స్టిక్ వంటిది
మీరు చివరిసారి నుండి మా చిత్రాన్ని గుర్తు.

1588
01:19:08,830 --> 01:19:11,670
మరియు నేను తిరగడానికి
తగినంత కాలంలో ఈ

1589
01:19:11,670 --> 01:19:15,040
నేను 32 బైట్లు కలిగి క్లెయిమ్
స్క్రీన్ మీద మెమరీ.

1590
01:19:15,040 --> 01:19:18,239
>> మాత్రమే ఇప్పుడు, వాస్తవానికి, నేను
ఇప్పటివరకు ఇక్కడ తెరమీద డ్రా.

1591
01:19:18,239 --> 01:19:20,280
నేను ముందుకు వెళ్ళడానికి వెళుతున్న
మరియు కేవలం కన్వెన్షన్ ద్వారా,

1592
01:19:20,280 --> 01:19:24,050
గా నా కంప్యూటర్ యొక్క మెమరీ డ్రా
గ్రిడ్, కాదు కేవలం సరళ రేఖ.

1593
01:19:24,050 --> 01:19:28,190
ముఖ్యంగా, నేను ఇప్పుడు ఆ దావా
ఈ గ్రిడ్, ఈ 8 4 గ్రిడ్,

1594
01:19:28,190 --> 01:19:31,800
అన్ని 32 బైట్లు సూచిస్తుంది
నా Mac లో లభ్య స్మృతి యొక్క,

1595
01:19:31,800 --> 01:19:33,030
లేదా నా PC లో అందుబాటులో.

1596
01:19:33,030 --> 01:19:34,780
వారు చుట్టడం చేస్తున్నారు
పై రెండు లైన్లు, కేవలం

1597
01:19:34,780 --> 01:19:38,030
అది తెరపై మరింత సరిపోయే ఎందుకంటే.

1598
01:19:38,030 --> 01:19:40,800
కానీ ఈ మొదటి బైట్.

1599
01:19:40,800 --> 01:19:41,990
ఈ రెండవ బైట్ ఉంది.

1600
01:19:41,990 --> 01:19:43,300
ఈ మూడవ బైట్ ఉంది.

1601
01:19:43,300 --> 01:19:45,310
>> మరియు ఈ 32 వ బైట్ ఉంది.

1602
01:19:45,310 --> 01:19:52,910
లేదా, మేము ఒక కంప్యూటర్ వంటి అనుకుంటే
శాస్త్రవేత్త, ఈ బైట్ 0, 1, 2, 3, 31 ఉంది.

1603
01:19:52,910 --> 01:19:55,950
సో మీరు 31 0 కలిగి, ఉంటే
మీరు 0 వద్ద లెక్కింపు మొదలు.

1604
01:19:55,950 --> 01:19:59,830
>> మేము ఒక కార్యక్రమం ఉపయోగించడానికి చేస్తే
కాల్స్ స్ట్రింగ్ పొందండి,

1605
01:19:59,830 --> 01:20:05,280
మనిషి నుండి ఒక స్ట్రింగ్ పొందండి
వంటి నేను Zamyla అని, Z-A-M- వై ఎల్-ఎ

1606
01:20:05,280 --> 01:20:09,430
ఎలా ప్రపంచంలో చేస్తుంది
కంప్యూటర్ ఉంచేందుకు ట్రాక్ను బైట్ యొక్క,

1607
01:20:09,430 --> 01:20:12,230
మెమరీ ఏ భాగం,
స్ట్రింగ్ చెందిన ఏ?

1608
01:20:12,230 --> 01:20:16,270
ఇతర మాటల్లో చెప్పాలంటే, కు కొనసాగితే
కంప్యూటర్ లోకి మరో పేరును టైప్

1609
01:20:16,270 --> 01:20:19,890
ఈ అండీ వంటి, కాల్
స్ట్రింగ్ రెండవసారి పొందడానికి,

1610
01:20:19,890 --> 01:20:23,030
ఒక-ఎన్-D- నేను వదులుకోవడానికి ఉంది
కంప్యూటర్ యొక్క మెమరీ అలాగే.

1611
01:20:23,030 --> 01:20:23,850
కానీ ఎలా?

1612
01:20:23,850 --> 01:20:29,700
>> బాగా, అది కింద హాజరవుతారు
హుడ్, ఏమి సి తీగలను నిల్వ చేసేటప్పుడు చేస్తుంది

1613
01:20:29,700 --> 01:20:35,080
మానవ రకాల, లేదా ఆ
కొన్ని ఇతర మూలం నుండి వచ్చి అది

1614
01:20:35,080 --> 01:20:39,190
వాటిని ముగింపు పూరించే
ఒక ప్రత్యేక పాత్ర బాక్ స్లాష్

1615
01:20:39,190 --> 01:20:44,750
కేవలం ఒక ప్రత్యేక మార్గం ఇది 0,
వరుసగా 80 బిట్స్ మాట్లాడుతూ.

1616
01:20:44,750 --> 01:20:47,950
>> కాబట్టి ఫంక్షన్ ఈ సంఖ్య 97 రీకాల్ ఉంది.

1617
01:20:47,950 --> 01:20:51,770
కాబట్టి 8 బిట్స్ కొన్ని నమూనా
దశాంశ సంఖ్య 97 సూచిస్తుంది.

1618
01:20:51,770 --> 01:20:58,070
ఈ బాక్ స్లాష్ 0 వాచ్యంగా సంఖ్య
0 అ.కే.అ nul, ఎన్ యు-L, ముందు కాకుండా,

1619
01:20:58,070 --> 01:20:59,630
ఎన్ యు-ఎల్-L, మేము గురించి మాట్లాడారు, దీనిలో.

1620
01:20:59,630 --> 01:21:05,700
కానీ ఇప్పుడు కోసం, కేవలం ఈ తెలుసు
బాక్ స్లాష్ 0 వరుసగా కేవలం 80 బిట్స్ ఉంది.

1621
01:21:05,700 --> 01:21:09,810
>> మరియు అది కేవలం ఈ లైన్
ఎడమ ఏదైనా చెప్పారు ఇసుక

1622
01:21:09,810 --> 01:21:12,610
ఒక స్ట్రింగ్ లేదా ఒక డేటా రకాన్ని చెందినది.

1623
01:21:12,610 --> 01:21:15,480
మరియు కుడి ఏదైనా
ఏదో చెందినది.

1624
01:21:15,480 --> 01:21:17,440
అండీ యొక్క పేరు, మరోవైపు,
ఇది కేవలం దృష్టి

1625
01:21:17,440 --> 01:21:21,310
ఇతర లైన్ లో వ్రాప్ ఏమవుతుంది
కానీ కేవలం ఒక సౌందర్య వివరాలు,

1626
01:21:21,310 --> 01:21:23,990
అదేవిధంగా nul ముగిస్తారు.

1627
01:21:23,990 --> 01:21:29,290
>> ఇది ఒక ఒక-ఎన్-D- నేను అక్షరాల స్ట్రింగ్ ఉంది
ప్లస్ ఐదవ రహస్య పాత్ర,

1628
01:21:29,290 --> 01:21:33,560
అన్ని 0 బిట్స్ కేవలం కొలతను గుర్తించడము కొరకు పెట్టబడిన
అండీ యొక్క పేరు యొక్క చివరకు అలాగే.

1629
01:21:33,560 --> 01:21:37,120
మరియు మేము కాల్ ఉంటే స్ట్రింగ్ మూడోసారి పొందండి
కంప్యూటర్ లో వంటి స్ట్రింగ్ పొందడానికి

1630
01:21:37,120 --> 01:21:44,210
మరియా, ఎం-ఎ-ఆర్-ఐ-ఎ, అదేవిధంగా మరియా ఉంది
పేరు nul బాక్ స్లాష్ 0 తో రద్దు.

1631
01:21:44,210 --> 01:21:47,170
>> ఈ తీరుకి భిన్నంగా ఉంటుంది
ఎలా నుండి ఒక కంప్యూటర్ సాధారణంగా చేస్తాను

1632
01:21:47,170 --> 01:21:51,850
పూర్ణాంకం, లేదా ఫ్లోట్ లేదా ఇతర నిల్వ
ఇప్పటికీ డేటా రకాలు, రీకాల్, ఎందుకంటే

1633
01:21:51,850 --> 01:21:57,420
పూర్ణాంకం సాధారణంగా 32 బిట్స్ ఉంది, లేదా
4 బైట్లు, లేదా ఉండవచ్చు కూడా 64 బిట్స్

1634
01:21:57,420 --> 01:21:59,100
లేదా ఎనిమిది బైట్లు.

1635
01:21:59,100 --> 01:22:02,620
కానీ ఒక కంప్యూటర్ లో అనేక ధాతువులు
ఒక ప్రోగ్రామింగ్ భాషలో

1636
01:22:02,620 --> 01:22:05,550
ఒక స్థిర సంఖ్యలో
hood-- కింద బైట్లు

1637
01:22:05,550 --> 01:22:08,100
బహుశా 1, బహుశా 2, బహుశా 4, బహుశా 8.

1638
01:22:08,100 --> 01:22:13,250
>> కానీ తీగలను, డిజైన్ ద్వారా, ఒక కలిగి
అక్షరాలు డైనమిక్ సంఖ్య.

1639
01:22:13,250 --> 01:22:16,980
మీరు వరకూ ముందుగానే తెలియదు
Z-A-M- వై ఎల్-A లో మానవ రకాల

1640
01:22:16,980 --> 01:22:21,400
లేదా M-ఎ-ఆర్-ఐ-ఎ, లేదా ఒక-ఎన్-D- నేను. మీకు తెలియదు
ఎన్ని సార్లు యూజర్ హిట్ అన్నారు

1641
01:22:21,400 --> 01:22:22,070
కీబోర్డు.

1642
01:22:22,070 --> 01:22:26,490
అందువలన, మీరు ఎలా తెలియదు
ముందుగానే అనేక పాత్రలు

1643
01:22:26,490 --> 01:22:27,540
మీరు అవసరం చూడాలని.

1644
01:22:27,540 --> 01:22:31,840
>> కాబట్టి సి కేవలం రకమైన ఒక వంటి ఆకులు
హుడ్ కింద రహస్య బ్రెడ్క్రంబ్ను

1645
01:22:31,840 --> 01:22:32,960
స్ట్రింగ్ చివరిలో.

1646
01:22:32,960 --> 01:22:39,280
మెమరీ Z-ఎ-M- వై ఎల్-ఎ నిల్వ తర్వాత,
అది కూడా కేవలం రెండు సమానం ఉంచుతుంది

1647
01:22:39,280 --> 01:22:40,210
కాలం.

1648
01:22:40,210 --> 01:22:45,060
ఒక వాక్యం చివరలో,
అది 80 బిట్స్ ఉంచుతుంది కాబట్టి

1649
01:22:45,060 --> 01:22:49,120
పేరు గుర్తుంచుకోవడం
Zamyla మొదలై ముగుస్తుంది.

1650
01:22:49,120 --> 01:22:51,490
>> కాబట్టి కనెక్షన్ ఏమిటి,
అప్పుడు, ఈ కార్యక్రమం ఎలా?

1651
01:22:51,490 --> 01:22:55,190
ఇక్కడ ఈ కార్యక్రమం, స్టిర్లింగ్,
కేవలం ఒక విధానం ఉంది

1652
01:22:55,190 --> 01:22:57,970
ఒక స్ట్రింగ్ పొందడానికి
వినియోగదారు నుండి, లైన్ 6.

1653
01:22:57,970 --> 01:23:01,160
లైన్ 7, నేను ఒక వేరియబుల్ డిక్లేర్
n అని మరియు అది 0 సమానంగా సెట్.

1654
01:23:01,160 --> 01:23:08,680
>> ఆపై లైన్ 8 లో, నేను కేవలం కోరారు
ప్రశ్న, ఎన్-th పాత్ర ఉన్నప్పటికీ

1655
01:23:08,680 --> 01:23:12,120
సమాన అన్ని 0 బిట్స్
ఇతర మాటలలో, కాదు

1656
01:23:12,120 --> 01:23:14,500
ఈ ప్రత్యేక సమాన
పాత్ర, బాక్ స్లాష్ 0, ఇది

1657
01:23:14,500 --> 01:23:18,470
ప్రత్యేకమైన nul పాత్ర ఉంది
ముందుకు వెళ్ళి కేవలం n పెంచుతాయి.

1658
01:23:18,470 --> 01:23:21,460
>> అది పనిని, మరియు ఉంచడానికి
అది చేయడం, అది పనిని.

1659
01:23:21,460 --> 01:23:23,430
కాబట్టి కూడా అయితే
మేము i ఉపయోగించిన గత

1660
01:23:23,430 --> 01:23:25,181
అది ఖచ్చితంగా మంచిది
n ఉపయోగించడానికి అర్థ,

1661
01:23:25,181 --> 01:23:27,430
మీరు ప్రయత్నిస్తున్న ఉంటే
ఉద్దేశపూర్వకంగా ఈ సమయం లెక్కలోనికి,

1662
01:23:27,430 --> 01:23:28,720
మరియు కేవలం n కాల్ అనుకుంటున్నారా.

1663
01:23:28,720 --> 01:23:34,720
ఈ కేవలం అడిగి ఉంచుతుంది,
లు అన్ని 0 సె యొక్క n-th పాత్ర?

1664
01:23:34,720 --> 01:23:38,470
లేకపోతే, తదుపరి రూపానికి చూడండి,
తదుపరి చూడాల్సి తదుపరి చూడండి,

1665
01:23:38,470 --> 01:23:39,460
తదుపరి చూడండి.

1666
01:23:39,460 --> 01:23:45,540
>> కానీ వెంటనే మీరు బాక్ స్లాష్ 0 చూడండి,
ఈ లూప్ లైన్ 9 11-- ద్వారా స్టాప్ల.

1667
01:23:45,540 --> 01:23:49,640
మీరు అయితే లూప్ బయటకు
ఆ వేరియబుల్ n లోపలి వదిలి

1668
01:23:49,640 --> 01:23:54,530
అన్ని యొక్క మొత్తం లెక్కింపు
మీరు చూసిన స్ట్రింగ్ లో అక్షరాలు,

1669
01:23:54,530 --> 01:23:55,660
తద్వారా అది ముద్రించిన.

1670
01:23:55,660 --> 01:23:56,760
కాబట్టి యొక్క ఈ ప్రయత్నించండి తెలియజేయండి.

1671
01:23:56,760 --> 01:23:59,500
>> లేకుండా, మరియు నాకు ముందుకు తెలియజేయండి
స్టిర్లింగ్ ఫంక్షన్ ఉపయోగించి,

1672
01:23:59,500 --> 01:24:04,240
కాని ఆ నా స్వంత స్వదేశ వెర్షన్ ఉపయోగించి
ఇక్కడ స్టిర్లింగ్ అని, నాకు ముందుకు తెలియజేయండి

1673
01:24:04,240 --> 01:24:07,700
మరియు రన్ ఫర్ స్టిర్లింగ్, ఏదో రకం
Zamyla, నేను ముందుగానే తెలుసు ఇది వంటి

1674
01:24:07,700 --> 01:24:08,670
ఆరు అక్షరాలు.

1675
01:24:08,670 --> 01:24:10,080
అది పని లేదో యొక్క చూసేలా.

1676
01:24:10,080 --> 01:24:10,920
నిజానికి, ఇది ఆరు వార్తలు.

1677
01:24:10,920 --> 01:24:15,257
యొక్క రాబ్ తో ప్రయత్నించండి లెట్, పాత్రలైన
మూడు అక్షరాలు అలాగే, మొదలగునవి.

1678
01:24:15,257 --> 01:24:17,340
కాబట్టి ఆ మాత్రం అంతే
హుడ్ కింద.

1679
01:24:17,340 --> 01:24:19,548
మరియు కనెక్షన్లు గమనించవచ్చు,
అప్పుడు, మొదటి వారం

1680
01:24:19,548 --> 01:24:22,370
తరగతి యొక్క, మేము గురించి మాట్లాడారు
నైరూప్యత, అలాంటిదే

1681
01:24:22,370 --> 01:24:26,960
ఇది ఆలోచనలు కేవలం ఈ పొరను ఉంది, లేదా
సంక్లిష్టత, ప్రాథమిక సూత్రాలు పైన.

1682
01:24:26,960 --> 01:24:30,710
ఇక్కడ, మేము విధమైన చూస్తున్నారా
స్టిర్లింగ్ యొక్క హుడ్ కింద,

1683
01:24:30,710 --> 01:24:33,510
దొరుకుతుందని, మాట్లాడటానికి,
అది ఎలా అమలుపరచాలి అవుతుంది?

1684
01:24:33,510 --> 01:24:35,232
>> మరియు మేము కాలేదు అది మేమే తిరిగి అమలు.

1685
01:24:35,232 --> 01:24:37,440
కానీ మేము ఎప్పుడూ మళ్ళీ చూడాలని
తిరిగి ప్రవేశపెట్టాలని స్టిర్లింగ్.

1686
01:24:37,440 --> 01:24:39,780
మేము కేవలం చూడాలని
క్రమంలో స్టిర్లింగ్ ఉపయోగించడానికి

1687
01:24:39,780 --> 01:24:42,100
నిజానికి కొన్ని తీగలను పొడవు పొందడానికి.

1688
01:24:42,100 --> 01:24:44,200
>> కాని ఏ మేజిక్ ఉంది
హుడ్ కింద.

1689
01:24:44,200 --> 01:24:46,716
మీకు తెలిస్తే కింద ఆ
హుడ్, ఒక స్ట్రింగ్

1690
01:24:46,716 --> 01:24:48,090
కేవలం అక్షరాలు క్రమం.

1691
01:24:48,090 --> 01:24:51,090
మరియు అక్షరాలు ఆ క్రమం
అన్ని సంఖ్యాపరంగా ప్రసంగించారు చేయవచ్చు

1692
01:24:51,090 --> 01:24:53,330
బ్రాకెట్ 0, బ్రాకెట్ తో
1, బ్రాకెట్ 2, మరియు మీరు

1693
01:24:53,330 --> 01:24:57,420
ఒక స్ట్రింగ్ చివరిలో ఒక అని తెలుసు
ప్రత్యేక పాత్ర, మీరు గుర్తించడానికి

1694
01:24:57,420 --> 01:25:01,710
ఒక అత్యంత ఏదైనా ఎలా
కార్యక్రమం, ఎందుకంటే అది boils

1695
01:25:01,710 --> 01:25:03,400
చదవడం మరియు మెమరీ రాస్తుంటే.

1696
01:25:03,400 --> 01:25:06,130
మారుతున్న మరియు చూస్తున్నాయి ఉంది
మెమరీ వద్ద, లేదా విషయాలు కదిలే

1697
01:25:06,130 --> 01:25:10,940
మెమరీలో చుట్టూ ముద్రణ విషయాలు
స్క్రీన్, మొదలగునవి.

1698
01:25:10,940 --> 01:25:14,800
>> కాబట్టి యొక్క ఇప్పుడు ఈ నూతనంగా ఉపయోగించడానికి అనుమతిస్తున్నట్లు
నిజానికి తీగలను ఏమి అవగాహన

1699
01:25:14,800 --> 01:25:17,910
హుడ్ కింద, మరియు
మరొక తిరిగి పొర పీల్

1700
01:25:17,910 --> 01:25:20,080
ఇప్పుడు వరకు మేము చేసిన ఆ
మొత్తంగా విస్మరిస్తూ జరిగింది.

1701
01:25:20,080 --> 01:25:22,650
ముఖ్యంగా, ఏ సమయంలో
మేము ఒక కార్యక్రమం అమలు చేసిన,

1702
01:25:22,650 --> 01:25:25,930
మేము కోడ్ యొక్క ఈ లైన్ కలిగింది
టాప్ సమీపంగా ప్రధాన ప్రకటించారు.

1703
01:25:25,930 --> 01:25:27,810
మరియు మేము Int ప్రధాన గర్జన పేర్కొన్న.

1704
01:25:27,810 --> 01:25:31,240
>> మరియు శూన్యమైన వక్ర లోపల
ప్రధాన అన్ని ఈ సమయంలో చెప్పడం జరిగింది ఉంది

1705
01:25:31,240 --> 01:25:33,440
కూడా ఏ వాదనలు తీసుకోదు.

1706
01:25:33,440 --> 01:25:36,210
ప్రధాన ఉంది, ఏదైనా ఇన్పుట్
వినియోగదారు నుండి పొందగలిగిన

1707
01:25:36,210 --> 01:25:39,020
కొన్ని ఇతర నుండి వచ్చి
విధానం వంటి ప్రధానంగా,

1708
01:25:39,020 --> 01:25:42,040
లేదా ఫ్లోట్ పొందుటకు, లేదా స్ట్రింగ్ పొందండి,
లేదా కొన్ని ఇతర చర్య.

1709
01:25:42,040 --> 01:25:44,710
కానీ ఆ అవుతుంది
మీరు ఒక ప్రోగ్రామ్ వ్రాస్తున్నప్పుడు,

1710
01:25:44,710 --> 01:25:47,690
మీరు నిజంగా పేర్కొనవచ్చు
ఈ కార్యక్రమం వలెను అని

1711
01:25:47,690 --> 01:25:51,730
మానవ నుండి ఇన్పుట్లను పడుతుంది
కమాండ్ లైన్ చూసుకుంటాడు.

1712
01:25:51,730 --> 01:25:56,310
>> ఇతర మాటలలో, అయినప్పటికీ మేము ఇప్పటివరకు
కేవలం హలో నడుస్తున్న చెయ్యబడింది హలో కలిగి

1713
01:25:56,310 --> 01:26:00,312
లేదా ఇలాంటి కార్యక్రమాలు, అన్ని
మేము ఉపయోగించి పరిష్కరించగలుగుతున్నాము ఇతర కార్యక్రమాలు,

1714
01:26:00,312 --> 01:26:02,770
మనం వ్రాసే లేదని,
, అవలంబిస్తున్నాయి అది కనిపిస్తుంది,

1715
01:26:02,770 --> 01:26:05,210
కమాండ్ లైన్ arguments--
తయారు వంటి విషయాలు.

1716
01:26:05,210 --> 01:26:07,450
మీరు తయారు వంటి ఏదో చెప్పే,
మరియు రెండవ పదం.

1717
01:26:07,450 --> 01:26:10,950
లేదా గణగణమని ద్వని మీరు గణగణమని ద్వని చేయు సే మరియు తరువాత
రెండవ పదం, ఒక ఫైల్ యొక్క పేరు.

1718
01:26:10,950 --> 01:26:14,410
>> లేదా ఆర్ఎం లేదా CP, మీరు బలం గా
చూసిన లేదా ఇప్పటికే ఉపయోగించిన

1719
01:26:14,410 --> 01:26:15,880
తొలగించండి లేదా కాపీ ఫైళ్లకు.

1720
01:26:15,880 --> 01:26:18,920
ఆ అన్ని పేరొందిన పడుతుంది
కమాండ్ లైన్ arguments--

1721
01:26:18,920 --> 01:26:21,130
టెర్మినల్ ప్రాంప్ట్ వద్ద అదనపు పదాలు.

1722
01:26:21,130 --> 01:26:23,260
అయితే ఇప్పటి వరకు, మేము
మమ్మల్ని కలిగి లేరు

1723
01:26:23,260 --> 01:26:27,080
నుండి ఇన్ పుట్ తీసుకోవటం ఈ లగ్జరీ
వినియోగదారు అతను లేదా ఆమె నిజానికి నడుస్తుంది ఉన్నప్పుడు

1724
01:26:27,080 --> 01:26:29,120
కమాండ్ లైన్ వద్ద కార్యక్రమం కూడా.

1725
01:26:29,120 --> 01:26:33,710
>> కానీ మేము తిరిగి ప్రకటిస్తూ ఆ చేయవచ్చు
ప్రధాన కలిగి లేదు కాబట్టి, ముందుకు వెళ్లడానికి

1726
01:26:33,710 --> 01:26:36,750
కుండలీకరణాల్లో రద్దు,
కానీ ఈ రెండు వాదనలు

1727
01:26:36,750 --> 01:26:40,600
మొదటి పూర్ణాంకం instead--,
మరియు రెండవ ఏదో

1728
01:26:40,600 --> 01:26:44,170
కొత్త, మేము కాల్ చూడాలని ఏదో
వ్యూహం, ఆత్మ లో పోలి ఏదో

1729
01:26:44,170 --> 01:26:49,220
మేము ఒక జాబితా స్క్రాచ్ చూసిన, కానీ
తీగలను యొక్క వ్యూహం, మేము వెంటనే చూస్తారు వంటి.

1730
01:26:49,220 --> 01:26:51,790
కానీ యొక్క ఈ చూద్దాం
ఉదాహరణకు చూస్తే, మేము ముందు

1731
01:26:51,790 --> 01:26:53,690
ఆ అర్ధమేమిటో వేరు.

1732
01:26:53,690 --> 01:26:56,520
>> నేను CS50 IDE వెళ్ళాలని కాబట్టి
ఇక్కడ, నేను ముందుకు మారారు

1733
01:26:56,520 --> 01:27:01,840
మరియు అని ఒక ఫైల్ లో ప్రకటించింది
క్రింది టెంప్లేట్ argv0.c.

1734
01:27:01,840 --> 01:27:04,120
మరియు మాత్రమే విషయం గమనించవచ్చు
ఇప్పటివరకు విభిన్నమైనది

1735
01:27:04,120 --> 01:27:08,570
నేను పూర్ణాంకానికి గర్జన మార్పుచేసేలా ఉంది
argc స్ట్రింగ్, ఓపెన్ బ్రాకెట్ argv దగ్గరి

1736
01:27:08,570 --> 01:27:09,070
బ్రాకెట్.

1737
01:27:09,070 --> 01:27:11,730
ఇప్పుడు కోసం గుర్తించరు ఉంది,
ఆ పరిధుల లోపల ఏమీ.

1738
01:27:11,730 --> 01:27:12,620
>> ఎటువంటి సంఖ్య ఉంది.

1739
01:27:12,620 --> 01:27:15,070
మరియు ఏ నేను లేదు, లేదా
n, లేదా ఏ ఇతర లేఖ.

1740
01:27:15,070 --> 01:27:17,010
నేను ఉపయోగించి వెబ్
ఇప్పుడు చదరపు బ్రాకెట్లలో,

1741
01:27:17,010 --> 01:27:19,510
కారణాల మేము వచ్చి చేస్తాము
తిరిగి ఒక క్షణం లో.

1742
01:27:19,510 --> 01:27:21,330
>> ఇప్పుడు నేను చేయ బోతున్నాను ఈ ఉంది.

1743
01:27:21,330 --> 01:27:26,680
సమానం argc సమానం ఉంటే 2 చేర్చాలని కోరుతున్నాయి
మరియు ఆ సమానం సమానం గుర్తు

1744
01:27:26,680 --> 01:27:30,040
సమానత్వం ఆపరేటర్లు పోల్చడం ఇది
ఎడమ మరియు సమానత్వం కోసం కుడి.

1745
01:27:30,040 --> 01:27:31,790
ఇది అప్పగించిన కాదు
ఇది ఆపరేటర్లు,

1746
01:27:31,790 --> 01:27:36,510
కాపీని అంటే ఒకే సమాన సైన్,
కుడి నుండి కొన్ని విలువ మిగిల్చింది.

1747
01:27:36,510 --> 01:27:42,840
>> argc సమానం 2 సమానం ఉంటే, నేను కావలసిన
సే, printf, హలో, శాతాలు, కొత్త లైన్

1748
01:27:42,840 --> 01:27:47,340
ఆపై in-- ప్లగ్ మరియు ఇక్కడ కొత్త వార్తలు
ట్రిక్ argv బ్రాకెట్ 1, కారణాల

1749
01:27:47,340 --> 01:27:48,840
మేము ఒక క్షణం లో తిరిగి వచ్చి మేము.

1750
01:27:48,840 --> 01:27:52,110
argc లేనప్పుడు ఎల్స్
సమానంగా 2, మీరు ఏమి?

1751
01:27:52,110 --> 01:27:57,400
మరియు, యొక్క కేవలం ముందుకు వెళ్ళి తెలపండి సాధారణ, ముద్రణ వంటి
ఏ ప్రత్యామ్నాయం తో ప్రపంచ హలో.

1752
01:27:57,400 --> 01:28:02,710
>> కాబట్టి ఇది ఆ argc, ఇది ఉంటే
వాదన లెక్కింపు ఉన్నచో 2 సమానం,

1753
01:28:02,710 --> 01:28:04,740
నేను ప్రింట్ వెళుతున్న
హలో ఏదో లేదా ఇతర.

1754
01:28:04,740 --> 01:28:07,560
లేకపోతే, అప్రమేయంగా, నేను ఉన్నాను
ప్రపంచ హలో ప్రింట్ వెళుతున్న.

1755
01:28:07,560 --> 01:28:08,770
కాబట్టి దీని అర్థం ఏమిటి?

1756
01:28:08,770 --> 01:28:15,550
>> బాగా, నాకు ముందుకు వెళ్లి సేవ్ చేసేలా
ఈ ఫైలు, ఆపై argv0 ఉందని,

1757
01:28:15,550 --> 01:28:18,940
ఆపై ./argv0 నమోదు చేయండి.

1758
01:28:18,940 --> 01:28:20,300
మరియు అది హలో ప్రపంచ చెప్పారు.

1759
01:28:20,300 --> 01:28:21,260
ఇప్పుడు, ఎందుకు అని?

1760
01:28:21,260 --> 01:28:24,730
>> సరే, మీరు ఎప్పుడైనా అవుతుంది
కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం అమలు,

1761
01:28:24,730 --> 01:28:29,570
మీరు మేము ఏమి చేస్తాము పూరించి
సాధారణంగా ఒక వాదన వెక్టర్ కాల్.

1762
01:28:29,570 --> 01:28:33,100
ఇతర మాటలలో, స్వయంచాలకంగా
కంప్యూటర్, ఆపరేటింగ్ సిస్టమ్,

1763
01:28:33,100 --> 01:28:38,340
మీ ప్రోగ్రామ్ చేతితో అన్నారు
కూడా అన్నీ జాబితా

1764
01:28:38,340 --> 01:28:40,850
మానవ వద్ద టైప్ చేసే
ప్రాంప్ట్, ఒకవేళ మీరు

1765
01:28:40,850 --> 01:28:43,790
ప్రోగ్రామర్ చేయాలనుకుంటున్నారా
ఆ సమాచారాన్ని కావొచ్చు.

1766
01:28:43,790 --> 01:28:48,540
మరియు ఈ సందర్భంలో, మాత్రమే పదం
నేను ప్రాంప్ట్ వద్ద టైప్ చేసిన ./argv0 ఉంది.

1767
01:28:48,540 --> 01:28:55,420
>> కాబట్టి అని వాదనలు సంఖ్య
నా ప్రోగ్రామ్ జారీ చేస్తున్నారు ఒకటి.

1768
01:28:55,420 --> 01:28:58,880
ఇతర మాటలలో, వాదన
లేకపోతే argc అని పిలుస్తారు, కౌంట్

1769
01:28:58,880 --> 01:29:00,970
ఇక్కడ పూర్ణాంకం వంటి, కేవలం ఒకటి.

1770
01:29:00,970 --> 01:29:03,000
ఒకటి, కోర్సు యొక్క, సమాన ఇద్దరు లేదు.

1771
01:29:03,000 --> 01:29:05,980
కాబట్టి ఈ hello, ముద్రిస్తుంది ఏమి ప్రపంచం.

1772
01:29:05,980 --> 01:29:08,170
>> కానీ నాకు ఈ ఎక్కడా తీసుకుందాం.

1773
01:29:08,170 --> 01:29:09,930
, నాకు చెప్పటానికి argv0 లెట్.

1774
01:29:09,930 --> 01:29:12,740
ఆపై మరియా గురించి?

1775
01:29:12,740 --> 01:29:14,990
Enter ని అప్పుడు.

1776
01:29:14,990 --> 01:29:18,020
>> మరియు అద్భుతంగా ఇక్కడ ఏమి గమనిస్తారు.

1777
01:29:18,020 --> 01:29:22,640
ఇప్పుడు, బదులుగా హలో వరల్డ్, నేను కలిగి
ఈ కార్యక్రమం యొక్క ప్రవర్తనను మార్చినది

1778
01:29:22,640 --> 01:29:26,310
పొందండి నుండి ఇన్పుట్ తీసుకోవడం ద్వారా
స్ట్రింగ్ లేదా కొన్ని ఇతర చర్య,

1779
01:29:26,310 --> 01:29:30,570
కానీ, స్పష్టంగా, నా కమాండ్ నుండి
కూడా, నేను నిజానికి టైప్ చేసిన ఏమి.

1780
01:29:30,570 --> 01:29:35,720
మరియు నేను ద్వారా మళ్లీ ఈ గేమ్ ప్లే చేయవచ్చు
ఉదాహరణకు, కు Stelios ఇది మారుతున్న.

1781
01:29:35,720 --> 01:29:38,400
>> మరియు ఇప్పుడు నేను ఇప్పటికీ మరొక పేరు చూడండి.

1782
01:29:38,400 --> 01:29:40,540
మరియు ఇక్కడ, నేను అండీ అనవచ్చు.

1783
01:29:40,540 --> 01:29:42,137
నేను Zamyla అనవచ్చు.

1784
01:29:42,137 --> 01:29:45,220
మరియు దినమెల్ల మేము ఈ గేమ్ ప్లే చేయవచ్చు,
కేవలం వివిధ విలువలు పూరించే,

1785
01:29:45,220 --> 01:29:49,550
నేను ఖచ్చితంగా అందించడానికి ఉన్నంతకాలం
ప్రాంప్ట్ వద్ద రెండు పదాలు,

1786
01:29:49,550 --> 01:29:52,260
argc, నా వాదన లెక్కింపు ఇటువంటి, 2.

1787
01:29:52,260 --> 01:29:57,240
>> నేను పేరు ప్లగ్ చూస్తారు
printf, ఇక్కడ ఈ పరిస్థితిలో చెల్లించాలి?

1788
01:29:57,240 --> 01:30:00,550
కాబట్టి మేము ఇప్పుడు కనిపించడం
వ్యక్తీకరణ సామర్ధ్యం

1789
01:30:00,550 --> 01:30:04,410
మరో యాంత్రికత ఇన్పుట్ తీసుకొనే,
అని పిలవబడే కమాండ్ లైన్ నుండి,

1790
01:30:04,410 --> 01:30:07,000
వేచి ఉండటం కంటే
వినియోగదారు ప్రోగ్రామ్ నడుస్తుంది వరకు,

1791
01:30:07,000 --> 01:30:10,220
ఆపై అతనిని లేదా ఆమెను ప్రాంప్ట్
స్ట్రింగ్ పొందండి లాగ ఉపయోగించి.

1792
01:30:10,220 --> 01:30:11,230
>> కాబట్టి ఈ ఏమి ఉంది?

1793
01:30:11,230 --> 01:30:15,010
Argc, మళ్ళీ, కేవలం ఒక పూర్ణ సంఖ్య,
words-- arguments-- సంఖ్య

1794
01:30:15,010 --> 01:30:18,540
ఆ యూజర్ వద్ద అందించబడింది
ప్రాంప్ట్, టెర్మినల్ విండో వద్ద,

1795
01:30:18,540 --> 01:30:20,110
కార్యక్రమం యొక్క పేరు సహా.

1796
01:30:20,110 --> 01:30:23,340
సో మా ./argv0 సమర్థవంతంగా ఉంది,
కార్యక్రమం యొక్క పేరు,

1797
01:30:23,340 --> 01:30:24,520
లేదా నేను అమలు ఎలా.

1798
01:30:24,520 --> 01:30:25,810
>> ఒక పదం గా లెక్కింపబడుతుంది.

1799
01:30:25,810 --> 01:30:27,080
కాబట్టి argc 1 ఉంటుంది.

1800
01:30:27,080 --> 01:30:29,750
కానీ నేను Stelios వ్రాస్తున్నప్పుడు, లేదా
Andi, లేదా Zamyla, లేదా మరియా,

1801
01:30:29,750 --> 01:30:31,660
ఆ వాదన లెక్కింపు ఇద్దరు అర్థం.

1802
01:30:31,660 --> 01:30:33,910
అందువలన ఇప్పుడు ఆమోదించబడ్డాయి రెండు పదాలు ఉన్నాయి అనిపిస్తుంది.

1803
01:30:33,910 --> 01:30:36,070
>> మరియు నోటీసు, మేము ఈ తర్కం కొనసాగించవచ్చు.

1804
01:30:36,070 --> 01:30:39,050
నేను నిజానికి చెబితే
Zamyla చాన్ అలాంటిదే

1805
01:30:39,050 --> 01:30:42,200
పూర్తి పేరు, తద్వారా ప్రయాణిస్తున్న
మొత్తం మూడు రకాల వాదనలు

1806
01:30:42,200 --> 01:30:47,410
ప్రస్తుతం మళ్లీ డిఫాల్ట్ చెప్పారు,
ఎందుకంటే, కోర్సు, 3 సమాన 2 చేస్తుంది.

1807
01:30:47,410 --> 01:30:54,080
>> కాబట్టి ఈ విధంగా, నేను ఉన్నాయి
argv ఈ కొత్త వాదన ద్వారా ప్రవేశించి

1808
01:30:54,080 --> 01:30:56,080
మేము సాంకేతికంగా అని
మేము కావలసిన ఏదైనా కాల్.

1809
01:30:56,080 --> 01:30:58,940
కానీ సాంప్రదాయకంగా, అంతే
argv మరియు argc, వరుసగా.

1810
01:30:58,940 --> 01:31:04,470
Argv, వాదన వెక్టర్, రకం
ఒక కార్యక్రమాలకు పర్యాయపదంగా

1811
01:31:04,470 --> 01:31:07,140
సి లో ఫీచర్ వ్యూహం అని.

1812
01:31:07,140 --> 01:31:14,410
>> ఒక అమరిక ఇదే విలువలు జాబితా
తిరిగి, తిరిగి, తిరిగి, తిరిగి.

1813
01:31:14,410 --> 01:31:17,810
ఇతర మాటలలో, ఒక ఇక్కడే ఉంది
ర్యామ్, తదుపరి కుడి అది పక్కన ఉంది,

1814
01:31:17,810 --> 01:31:18,800
మరియు కుడి అది ప్రక్కన.

1815
01:31:18,800 --> 01:31:20,101
వారు అన్ని చోట్ల లేదు.

1816
01:31:20,101 --> 01:31:23,100
మరియు ఆ తరువాతి ఘట్టానికి ఇక్కడ విషయాలు
అన్ని మెమరీలో చోట్ల ఉన్నాయి,

1817
01:31:23,100 --> 01:31:25,082
నిజానికి ఒక శక్తివంతమైన ఫీచర్ ఉంటుంది.

1818
01:31:25,082 --> 01:31:28,040
కానీ మేము మేము ఆ వచ్చి చేస్తాము
ఫ్యాన్సియెర్స్ డేటా నిర్మాణాలు గురించి మాట్లాడటానికి.

1819
01:31:28,040 --> 01:31:32,260
ఇప్పుడు కోసం, ఒక అర్రే ఒక ఉంది
పక్కపక్క మెమరీ భాగం,

1820
01:31:32,260 --> 01:31:36,520
దీని అంశాలు ప్రతి
తిరిగి, తిరిగి, తిరిగి తిరిగి,

1821
01:31:36,520 --> 01:31:38,050
మరియు సాధారణంగా అదే రకం.

1822
01:31:38,050 --> 01:31:42,630
>> సో మీరు ఒక నుండి గురించి అనుకుంటే
క్షణం క్రితం, ఒక స్ట్రింగ్ ఏమిటి?

1823
01:31:42,630 --> 01:31:50,460
Well, ఒక స్ట్రింగ్, Zamyla వంటి,
Z-A-M- వై ఎల్-ఎ, సాంకేతికంగా, ఉంది,

1824
01:31:50,460 --> 01:31:51,400
కేవలం ఒక శ్రేణి.

1825
01:31:51,400 --> 01:31:53,700
ఇది అక్షరాలు యొక్క వ్యూహం ఉంది.

1826
01:31:53,700 --> 01:31:59,250
>> కాబట్టి మేము నిజంగా ఈ వంటి డ్రా అయితే నేను
మెమరీ భాగం గా, ఇంతకు ముందు,

1827
01:31:59,250 --> 01:32:04,510
వీటిల్లో ప్రతి అవుతుంది
అక్షరాలు ఒక బైట్ తీసుకుంటుంది.

1828
01:32:04,510 --> 01:32:07,630
ఆపై ప్రత్యేక వార్తలు
కాపలాదారుడు పాత్ర, బాక్ స్లాష్ 0,

1829
01:32:07,630 --> 01:32:12,360
లేదా అన్ని ఎనిమిది 0 బిట్స్
ఆ స్ట్రింగ్ ముగింపు కొలతను గుర్తించడము.

1830
01:32:12,360 --> 01:32:15,090
సో ఒక స్ట్రింగ్, అది మారుతుంది
బయటకు, unquote స్ట్రింగ్ కోట్

1831
01:32:15,090 --> 01:32:20,580
కేవలం chara-- యొక్క వ్యూహం ఉంది
ఒక వాస్తవ డేటా రకం ఉండటం చార్.

1832
01:32:20,580 --> 01:32:24,560
>> ఇప్పుడు argv, meanwhile--
యొక్క తిరిగి కార్యక్రమానికి వీడలేదు.

1833
01:32:24,560 --> 01:32:29,582
Argv, మేము పదం అయినప్పటికీ
స్ట్రింగ్ ఇక్కడ, ఒక స్ట్రింగ్ కూడా ఉంది.

1834
01:32:29,582 --> 01:32:33,640
Argv, వాదన వెక్టర్,
తీగలను యొక్క వ్యూహం ఉంది.

1835
01:32:33,640 --> 01:32:37,620
>> మీరు వ్యూహం ఉండవచ్చు కాబట్టి కేవలం
అక్షరాలు, మీరు అధిక స్థాయి కలిగి ఉంటుంది,

1836
01:32:37,620 --> 01:32:46,279
strings-- యొక్క వ్యూహం కాబట్టి, ఉదాహరణకు,
నేను ఒక క్షణం క్రితం టైప్ చేసినప్పుడు ./argv0

1837
01:32:46,279 --> 01:33:00,150
argv0, స్పేస్ Z-A-M- వై-L- ఒక, నేను పేర్కొన్నారు
argv దానిని ./argv0 రెండు తీగలను కలిగిఉండగా,

1838
01:33:00,150 --> 01:33:03,185
మరియు Z-ఎ-M- వై ఎల్ ఎ. లో
ఇతర మాటలలో, argc 2 ఉంది.

1839
01:33:03,185 --> 01:33:03,980
ఎందుకు అని?

1840
01:33:03,980 --> 01:33:08,370
>> బాగా, సమర్థవంతంగా, ఏం జరగబోతోంది
ఉంది ఈ తీగలు ప్రతి యొక్క

1841
01:33:08,370 --> 01:33:13,990
అక్షరాలు యొక్క వ్యూహం, కోర్సు యొక్క, ఉంది
ముందు, దీని ప్రతి అక్షరాలు

1842
01:33:13,990 --> 01:33:15,670
ఒక బైట్ తీసుకుంటుంది.

1843
01:33:15,670 --> 01:33:19,720
మరియు వాస్తవ 0 తికమక లేదు
0 కార్యక్రమం యొక్క పేరు లో,

1844
01:33:19,720 --> 01:33:22,040
అన్ని 80 బిట్స్ అర్థం.

1845
01:33:22,040 --> 01:33:27,140
మరియు Zamyla, మరోవైపు, ఇప్పటికీ ఉంది
కూడా అక్షరాలు యొక్క వ్యూహం.

1846
01:33:27,140 --> 01:33:31,450
>> కాబట్టి రోజు చివరిలో, అది నిజంగా
హుడ్ కింద ఈ కనిపిస్తోంది.

1847
01:33:31,450 --> 01:33:38,800
కానీ ఎలా ప్రధాన స్వభావం ద్వారా, argv
రచనలు, నాకు ఈ అన్ని వ్రాప్ అనుమతిస్తుంది

1848
01:33:38,800 --> 01:33:44,810
లోకి, మీరు రెడీ ఉంటే, ఒక పెద్ద శ్రేణి
మేము కొద్దిగా పైగా సులభతరం, ఆ

1849
01:33:44,810 --> 01:33:48,180
చిత్రాన్ని వంటి మరియు లేదు కనిపిస్తుంది ఏమి
చాలా ఉన్నాయి స్కేల్ గీసి,

1850
01:33:48,180 --> 01:33:56,720
ఈ శ్రేణి మొదటి, కేవలం పరిమాణం 2 యొక్క
ఒక స్ట్రింగ్ కలిగి మూలకం

1851
01:33:56,720 --> 01:33:59,230
రెండవ మూలకం
ఇది ఒక స్ట్రింగ్ కలిగి.

1852
01:33:59,230 --> 01:34:01,687
మరియు, క్రమంగా, మీరు
రకమైన ప్రతి లో జూమ్

1853
01:34:01,687 --> 01:34:03,770
ఆ తీగలను యొక్క ఏమి మీరు
హుడ్ కింద చూడండి

1854
01:34:03,770 --> 01:34:07,190
ప్రతి స్ట్రింగ్ కేవలం ఉంది
అక్షరాలు యొక్క వ్యూహం.

1855
01:34:07,190 --> 01:34:11,680
>> ఇప్పుడు, కేవలం తీగలను వంటి,
మేము ప్రాప్యత పొందుటకు పోయారు

1856
01:34:11,680 --> 01:34:15,260
ఒక స్ట్రింగ్ లో i-th పాత్ర
ఆ చదరపు బ్రాకెట్ సంజ్ఞామానం.

1857
01:34:15,260 --> 01:34:17,320
అదేవిధంగా, శ్రేణితో
సాధారణంగా, మేము

1858
01:34:17,320 --> 01:34:22,700
పొందుటకు చదరపు బ్రాకెట్ సంజ్ఞామానం
వ్యూహంలో తీగలను ఎన్ని వద్ద?

1859
01:34:22,700 --> 01:34:25,100
ఉదాహరణకు, నాకు తెలియజేయండి
ముందుకు వెళ్ళి దీన్ని.

1860
01:34:25,100 --> 01:34:32,420
>> నాకు ముందుకు వెళ్లి argv1.c సృష్టించడానికి లెట్,
ఇది కొద్దిగా భిన్నంగా ఈ సమయంలో ఉంది.

1861
01:34:32,420 --> 01:34:35,635
బదులుగా argc2 కోసం తనిఖీ యొక్క,
నేను బదులుగా దీన్ని వెళుతున్న.

1862
01:34:35,635 --> 01:34:41,270
నేను 0 పొందుటకు Int కోసం, నేను తక్కువ
argc కంటే, నేను ప్లస్ ప్లస్,

1863
01:34:41,270 --> 01:34:47,920
ఆపై ఈ లోపల బయటకు ప్రింట్,
శాతం లు, కొత్త లైన్, మరియు అప్పుడు

1864
01:34:47,920 --> 01:34:50,740
argv బ్రాకెట్ i.

1865
01:34:50,740 --> 01:34:55,220
>> కాబట్టి ఇతర మాటలలో, నేను వ్యవహరించే కాదు
క్షణం వద్ద వ్యక్తిగత అక్షరాలు.

1866
01:34:55,220 --> 01:35:00,190
Argv, ఈ ఖాళీ చదరపు సూచించినట్లు
పేరు argv యొక్క కుడి జంట కలుపులు,

1867
01:35:00,190 --> 01:35:03,320
తీగలను యొక్క వ్యూహం ఉంది argv అర్థం.

1868
01:35:03,320 --> 01:35:04,870
మరియు argc కేవలం ఒక పూర్ణాంకానికి ఉంది.

1869
01:35:04,870 --> 01:35:08,800
>> ఇక్కడ ఈ లైన్, 6, ఉంది
సెట్ మాట్లాడుతూ నేను 0 సమం.

1870
01:35:08,800 --> 01:35:11,980
అన్ని మార్గం కౌంట్,
కానీ argc మినహాయించి.

1871
01:35:11,980 --> 01:35:14,010
ఆపై ప్రతి మళ్ళా న,
ఒక స్ట్రింగ్ ప్రింట్.

1872
01:35:14,010 --> 01:35:14,800
స్ట్రింగ్?

1873
01:35:14,800 --> 01:35:17,270
>> argv లో నేను-వ స్ట్రింగ్.

1874
01:35:17,270 --> 01:35:19,530
కాబట్టి నేను ముందు అయితే
చదరపు బ్రాకెట్ ఉపయోగించి

1875
01:35:19,530 --> 01:35:22,180
ith వద్ద పొందడానికి సంజ్ఞామానం
ఒక స్ట్రింగ్ లో పాత్ర ఇప్పుడు

1876
01:35:22,180 --> 01:35:27,240
నేను చదరపు బ్రాకెట్ సంజ్ఞామానం ఉపయోగించి వెబ్
ఒక యెరే నందలి ith స్ట్రింగ్ వద్ద పొందడానికి.

1877
01:35:27,240 --> 01:35:30,310
కనుక ఇది ఒక పొర రకంగా
పైన, సంభావితంగా.

1878
01:35:30,310 --> 01:35:35,390
>> కాబట్టి ఈ ఏమి గురించి చక్కగా ఉంది
ఇప్పుడు కార్యక్రమం, నేను ఇది argv1 కంపైల్ ఉంటే,

1879
01:35:35,390 --> 01:35:42,067
ఆపై ./argv1 చేయండి, తరువాత టైప్
foo బార్ బాజ్ లాగ,

1880
01:35:42,067 --> 01:35:45,400
మూడు డిఫాల్ట్ పదాలు ఒక ఉన్నాయి
కంప్యూటర్ శాస్త్రవేత్త ఏ సమయంలో చేరుకుంటుంది

1881
01:35:45,400 --> 01:35:51,010
అతను లేదా ఆమె కొన్ని హోల్డర్ పదాలు అవసరం,
ఎంటర్ నొక్కండి, ఆ పదాల్లోని,

1882
01:35:51,010 --> 01:35:54,980
కార్యక్రమం యొక్క పేరు, సహా
మొదటి స్థానంలో argv లో ఉంది

1883
01:35:54,980 --> 01:35:58,320
ఒక సమయంలో ఒక ముద్రించబడ్డాయి ముగుస్తుంది.

1884
01:35:58,320 --> 01:36:05,290
నేను దీన్ని మార్చి, నేను చెప్పుకోవాలంటే
ఇది argv1 Zamyla చాన్ అలాంటిదే

1885
01:36:05,290 --> 01:36:08,800
మేము ఆ మూడు పొందడానికి
argv0 ఇది మాటలు,

1886
01:36:08,800 --> 01:36:14,400
ఇది argv1, argv2, ఈ ఎందుకంటే
కేసు argc, లెక్కింపు, 3.

1887
01:36:14,400 --> 01:36:20,020
>> కానీ ఏమి చక్కగా ఉంది మీరు అర్థం ఉంటే
ఆ argv కేవలం తీగలను యొక్క వ్యూహం ఉంది,

1888
01:36:20,020 --> 01:36:24,910
మరియు మీరు ఒక స్ట్రింగ్ అర్థం
అక్షరాలు యొక్క వ్యూహం ఉంది,

1889
01:36:24,910 --> 01:36:29,470
మేము నిజంగా రకమైన ఈ ఉపయోగించవచ్చు
చదరపు బ్రాకెట్ సంజ్ఞామానం అనేకసార్లు

1890
01:36:29,470 --> 01:36:33,320
ఒక స్ట్రింగ్ ఎంచుకోండి, ఆపై ఎంచుకోండి
స్ట్రింగ్ లోపల ఒక పాత్ర,

1891
01:36:33,320 --> 01:36:35,730
ఈ క్రింది విధంగా లోతైన లో డైవింగ్.

1892
01:36:35,730 --> 01:36:40,100
ఈ ఉదాహరణలో, నాకు వీడలేదు
ముందుకు మరియు ఈ argv2.c కాల్.

1893
01:36:40,100 --> 01:36:43,920

1894
01:36:43,920 --> 01:36:50,180
మరియు ఈ ఉదాహరణలో, నాకు ముందుకు తెలియజేయండి
మరియు నేను 0 పొందుటకు Int కోసం కింది చేయండి,

1895
01:36:50,180 --> 01:36:53,286
నేను, argc కంటే తక్కువ i ప్లస్
ప్లస్, ముందు వలె.

1896
01:36:53,286 --> 01:36:55,910
కాబట్టి ఇతర words-- మరియు ఇప్పుడు ఈ
తగినంత క్లిష్టమైన పెరిగిపోతుంది.

1897
01:36:55,910 --> 01:36:59,940
అప్పుడు నేను చెప్పాను వెళుతున్న
argv తీగలను పైగా iterate,

1898
01:36:59,940 --> 01:37:01,294
నాకు వ్యాఖ్యగా.

1899
01:37:01,294 --> 01:37:03,960
ఆపై నేను ఒక కలిగి వెళుతున్న
లూప్ యున్న, బహుశా మీరు

1900
01:37:03,960 --> 01:37:06,290
చేసిన, లేదా భావిస్తారు
స్క్రాచ్ లో, చేయడం పేరు,

1901
01:37:06,290 --> 01:37:08,600
నేను ఉన్నాను పూర్ణాంకానికి చెప్పడానికి వెళుతున్నాను
మళ్ళీ నేను ఉపయోగించడానికి వెళ్ళడం లేదు,

1902
01:37:08,600 --> 01:37:12,590
నేను షాడో వద్దు ఎందుకంటే, లేదా
విధమైన ఇప్పటికే నేను తిరిగి రాస్తుంది.

1903
01:37:12,590 --> 01:37:15,780
>> నేను ఎందుకంటే, బదులుగా, j చెప్పే వెళుతున్న
ఆ i తరువాత వేరియబుల్ నా ప్రయాణంలో వార్తలు,

1904
01:37:15,780 --> 01:37:18,590
నేను దీనికై
సాధారణ సంఖ్యలు కౌంట్.

1905
01:37:18,590 --> 01:37:28,850
j గెట్స్ 0 ఉంది మరియు కూడా, n అన్నారు
argv బ్రాకెట్ i యొక్క దృఢమైన పొడవు పొందడానికి,

1906
01:37:28,850 --> 01:37:36,030
చాలా కాలం జె ఎం కంటే తక్కువ,
j ప్లస్ ప్లస్, క్రింది వాటిని.

1907
01:37:36,030 --> 01:37:37,500
మరియు ఇక్కడ ఆసక్తికరమైన భాగం.

1908
01:37:37,500 --> 01:37:46,330
>> ఒక పాత్ర మరియు ఒక కొత్త లైన్ ప్రింట్
argv బ్రాకెట్ నేను, బ్రాకెట్ j పూరించే.

1909
01:37:46,330 --> 01:37:47,940
OK, కాబట్టి నాకు ఇక్కడ కొన్ని వ్యాఖ్యలు జోడించడానికి అనుమతిస్తుంది.

1910
01:37:47,940 --> 01:37:54,820
అక్షరాలు మీద iterate
ప్రస్తుత స్ట్రింగ్ లో

1911
01:37:54,820 --> 01:38:02,290
నేను-వ స్ట్రింగ్ లో ముద్రణ జె-th పాత్ర.

1912
01:38:02,290 --> 01:38:04,630
కాబట్టి ఇప్పుడు, యొక్క పరిశీలిద్దాం
ఏమి ఈ వ్యాఖ్యలు అర్థం.

1913
01:38:04,630 --> 01:38:06,750
>> తీగలను పైగా iterate
argv-- ఎన్ని

1914
01:38:06,750 --> 01:38:09,300
తీగలను ఒక అర్రే, argv ఉన్నాయి?

1915
01:38:09,300 --> 01:38:13,420
Argc అనేక, కాబట్టి నేను iterating ఉన్నాను
నుండి నేను argc వరకు సమం 0.

1916
01:38:13,420 --> 01:38:20,020
ఇంతలో, ఎన్ని అక్షరాలు
argv లో నేను-వ స్ట్రింగ్ లో?

1917
01:38:20,020 --> 01:38:22,880
>> Well, ఆ సమాధానం పొందడానికి
నేను స్ట్రింగ్ పొడవు కాల్

1918
01:38:22,880 --> 01:38:26,810
ప్రస్తుత స్ట్రింగ్ నేను సంరక్షణకు
argv బ్రాకెట్ i ఉంది, ఇది గురించి.

1919
01:38:26,810 --> 01:38:30,090
నేను తాత్కాలికంగా ఆ నిల్వ వెళుతున్న
విలువ n, కేవలం చేజింగ్ ప్రయోజనాల కోసం,

1920
01:38:30,090 --> 01:38:31,590
సామర్థ్యం కోసం అది గుర్తుంచుకోవడానికి.

1921
01:38:31,590 --> 01:38:36,330
ఆపై నేను 0 j ప్రారంభించడం వెళుతున్న
j కంటే తక్కువ ఉన్నంతకాలం కొనసాగించడాన్ని,

1922
01:38:36,330 --> 01:38:38,430
మరియు ప్రతి మళ్ళా పెంపు j న.

1923
01:38:38,430 --> 01:38:41,030
>> ఆపై ఇక్కడ, పర్
లైన్ 12 లో నా వ్యాఖ్య,

1924
01:38:41,030 --> 01:38:43,390
ఒక పాత్రను ప్రింట్,
ఒక కొత్త పంక్తి తర్వాత,

1925
01:38:43,390 --> 01:38:48,140
ప్రత్యేకంగా argv బ్రాకెట్
నేను నాకు నేను-వ స్ట్రింగ్ ఇస్తుంది

1926
01:38:48,140 --> 01:38:51,690
argv-- కాబట్టి మొదటి పదం లో,
రెండవ పదం, మూడవ పదం సంసార.

1927
01:38:51,690 --> 01:38:57,370
లోతైన లో తరువాత j పడిపోవడంతో, మరియు గెట్స్
నాకు ఆ పదం యొక్క j-th పాత్ర.

1928
01:38:57,370 --> 01:39:02,200
అందువలన, ప్రభావం లో, మీరు చికిత్స చేయవచ్చు
argv ఒక బహుళ పరిమాణాల వంటి,

1929
01:39:02,200 --> 01:39:06,050
ద్విమితీయ, వ్యూహం,
అనగా కనిపిస్తోంది ప్రతి పదం రకమైన

1930
01:39:06,050 --> 01:39:08,580
మీ మనస్సు యొక్క ఈ వంటి
కన్ను, ప్రతి పాత్ర

1931
01:39:08,580 --> 01:39:10,930
రకమైన కూడి ఉంది
ఒక కాలమ్, ఆ సహాయం చేస్తుంది.

1932
01:39:10,930 --> 01:39:13,260
>> వాస్తవంలో, మేము బాధించటం
భవిష్యత్తులో వారాల్లో ఈ వేరుగా,

1933
01:39:13,260 --> 01:39:15,580
అది కొద్దిగా చేస్తాడు
కంటే మరింత అధునాతన.

1934
01:39:15,580 --> 01:39:17,800
కానీ మీరు నిజంగా చెయ్యవచ్చు
ఇప్పుడు కోసం, ఆ భావిస్తారు,

1935
01:39:17,800 --> 01:39:22,110
ఈ రెండు డైమెన్షనల్ గా
అర్రే, అనగా ఒక వ్యక్తి దాని స్థాయి

1936
01:39:22,110 --> 01:39:23,260
తీగలను అన్ని ఉంది.

1937
01:39:23,260 --> 01:39:26,760
ఆపై మీరు లోతైన, మీరు ఈత కొట్టడానికి ఉంటే
వ్యక్తిగత దొరకని అక్షరాలు

1938
01:39:26,760 --> 01:39:29,600
ఇక్కడ ఈ సంజ్ఞామానం ఉపయోగించి అందులో.

1939
01:39:29,600 --> 01:39:31,620
>> కాబట్టి నికర ప్రభావం ఏమిటి?

1940
01:39:31,620 --> 01:39:34,970
నాకు ముందుకు వెళ్లి
argv2-- అది రంధ్రాన్ని సరి చేయు చేయడానికి.

1941
01:39:34,970 --> 01:39:36,210
నేను ఇక్కడ పొరపాటు.

1942
01:39:36,210 --> 01:39:40,160
పరిపూర్ణంగా ప్రకటించారు
లైబ్రరీ ఫంక్షన్ స్టిర్లింగ్.

1943
01:39:40,160 --> 01:39:42,190
కాబట్టి ఈ సమయం, అది
బహుశా తగిన

1944
01:39:42,190 --> 01:39:45,130
మేము విధమైన పూర్తి చేస్తున్న
ఖచ్చితంగా మేము ప్రారంభించారు.

1945
01:39:45,130 --> 01:39:48,160
>> నేను ఇరుక్కొనిపోయింది పరిపూర్ణంగా ప్రకటించారు
లైబ్రరీ ఫంక్షన్ స్టిర్లింగ్.

1946
01:39:48,160 --> 01:39:48,987
సరే, ఒక నిమిషం వేచి.

1947
01:39:48,987 --> 01:39:51,070
నేను ముఖ్యంగా, గుర్తుంచుకోవాలి
నుండి అది ఇక్కడే ఉంది.

1948
01:39:51,070 --> 01:39:54,490
నేను string.h ఉన్నాయి అవసరం
కార్యక్రమం యొక్క ఈ వెర్షన్.

1949
01:39:54,490 --> 01:40:00,050
>> నాకు ముందుకు వెళ్లి ఉన్నాయి లెట్
string.h, సేవ్, ముందుకు వెళ్ళి

1950
01:40:00,050 --> 01:40:04,460
మరియు argv2 కంపైల్ చెయ్యండి.

1951
01:40:04,460 --> 01:40:08,390
ఇప్పుడు, ఇక్కడ మనం, argv2 చేయడానికి ఎంటర్ వెళ్ళండి.

1952
01:40:08,390 --> 01:40:10,590
మరియు అది ఒక చిన్న అయితే
మొదటి చూపులో గుప్తమైన,

1953
01:40:10,590 --> 01:40:15,690
నిజానికి, నోటీసు, ఏమి
ముద్రించబడుతుంది డాట్ argv2 ఉంది.

1954
01:40:15,690 --> 01:40:19,970
>> కానీ నేను తరువాత కొన్ని పదాలు టైప్ చేస్తే
ప్రాంప్ట్, argv2 Zamyla చాన్ వంటి,

1955
01:40:19,970 --> 01:40:22,560
కూడా కొద్దిగా, ఎంటర్
మొదటి చూపులో గుప్తమైన.

1956
01:40:22,560 --> 01:40:30,540
కానీ మేము తిరిగి అప్ స్క్రోల్ చేయండి,
./argv2 Z-A-M- వై ఎల్ ఎ సి హెచ్ ఎ-ఎన్.

1957
01:40:30,540 --> 01:40:32,190
కాబట్టి మేము ప్రతి పదం మీద iterated చేసిన.

1958
01:40:32,190 --> 01:40:37,770
మరియు, క్రమంగా, మేము పైగా iterated చేసిన
ఒక పదం లోపల ప్రతి పాత్ర.

1959
01:40:37,770 --> 01:40:40,040
>> ఇప్పుడు, ఈ అన్ని తర్వాత,
అక్కడ తెలుసుకుంటారు

1960
01:40:40,040 --> 01:40:43,120
ఒక ఇతర వివరాలు మేము రకమైన ఉన్నాను
ఈ మొత్తం సమయం విస్మరిస్తూ.

1961
01:40:43,120 --> 01:40:46,180
మేము కేవలం దూరంగా ఆటపట్టించాడు ఏమి
ప్రధాన యొక్క ఇన్పుట్లను ఉంటుంది?

1962
01:40:46,180 --> 01:40:47,780
ఏ ప్రధాన యొక్క అవుట్పుట్ గురించి?

1963
01:40:47,780 --> 01:40:50,540
>> ఈ సమయంలో అన్ని, మేము పరిష్కరించగలుగుతున్నాము
కేవలం కాపీ మరియు పేస్ట్

1964
01:40:50,540 --> 01:40:53,870
ప్రధాన ముందు పదం Int,
మీరు చూడవచ్చు అయితే ఆన్లైన్,

1965
01:40:53,870 --> 01:40:58,340
కొన్నిసార్లు తప్పుగా పాత సంస్కరణల్లో
C మరియు కంపైలర్లు యొక్క, వారు గర్జన చెబుతారు,

1966
01:40:58,340 --> 01:40:59,410
లేదా అన్ని వద్ద ఏమీ.

1967
01:40:59,410 --> 01:41:01,580
కానీ, నిజానికి, వెర్షన్ కోసం
సి మనం ఉపయోగిస్తున్న చేస్తున్న,

1968
01:41:01,580 --> 01:41:06,180
సి 11, లేదా 2011, తెలుసుకోవటం
అది పూర్ణాంకానికి ఉండాలి.

1969
01:41:06,180 --> 01:41:09,300
మరియు అది గాని ఉండాలి
తప్ప లేదా argc మరియు ఇక్కడ argv.

1970
01:41:09,300 --> 01:41:10,790
>> కానీ ఎందుకు Int ప్రధాన?

1971
01:41:10,790 --> 01:41:12,480
నిజానికి ఏమి తిరిగి?

1972
01:41:12,480 --> 01:41:16,280
సరే, ఈ సమయంలో అన్ని అవుతుంది
ఏ సమయంలో మీరు ఒక ప్రోగ్రామ్ ప్రధాన వ్రాయలేదు

1973
01:41:16,280 --> 01:41:18,440
ఎప్పుడూ ఏదో తిరిగి.

1974
01:41:18,440 --> 01:41:19,960
కానీ అది చాలా రహస్యంగా చేస్తోంది.

1975
01:41:19,960 --> 01:41:23,350
>> ఒక విషయం ఉంది
Int, లైన్ గా 5 సూచిస్తుంది.

1976
01:41:23,350 --> 01:41:24,225
కానీ ఏమి పూర్ణాంకానికి?

1977
01:41:24,225 --> 01:41:26,100
Well, ఈ ఉంది
ప్రోగ్రామింగ్ సమావేశం,

1978
01:41:26,100 --> 01:41:29,790
ఏమీ కలిగి ఉంటే అనగా
తప్పు పోయింది మరియు అన్ని బాగా ఉంటుంది,

1979
01:41:29,790 --> 01:41:34,250
కార్యక్రమాలు మరియు విధులు సాధారణంగా
return-- కొంతవరకు counterintuitively--

1980
01:41:34,250 --> 01:41:35,230
0.

1981
01:41:35,230 --> 01:41:38,070
0 సాధారణంగా అన్ని బాగా సూచిస్తుంది.

1982
01:41:38,070 --> 01:41:40,610
మీరు ఆలోచించవచ్చు కాబట్టి అయినప్పటికీ
పలు సందర్భాల్లో తప్పుడు అది

1983
01:41:40,610 --> 01:41:42,930
నిజానికి సాధారణంగా ఒక మంచి విషయం అర్థం

1984
01:41:42,930 --> 01:41:49,560
>> ఇంతలో, ఒక ప్రోగ్రామ్ 1 తిరిగి ఉంటే,
లేదా ప్రతికూల 1, లేదా 5, లేదా ప్రతికూల 42,

1985
01:41:49,560 --> 01:41:52,941
లేదా ఏ కాని 0 విలువ,
సాధారణంగా సూచిస్తుంది

1986
01:41:52,941 --> 01:41:54,190
ఏదో తప్పు పోయిందో.

1987
01:41:54,190 --> 01:41:56,700
నిజానికి, మీ స్వంత Mac లేదా PC లో,
మీరు నిజంగా చూసిన ఉండవచ్చు

1988
01:41:56,700 --> 01:42:01,050
ఒక దోష సందేశం అనగా ఇది
ఏదో లేదా ఇతర, లోపం చెప్పారు

1989
01:42:01,050 --> 01:42:04,940
కోడ్ ప్రతికూల 42, లేదా లోపం కోడ్
23, లేదా అలాంటిదే.

1990
01:42:04,940 --> 01:42:08,980
ఆ సంఖ్యను సాధారణంగా కేవలం ఒక సూచనను ఉంది
ప్రోగ్రామర్, లేదా కంపెనీకి

1991
01:42:08,980 --> 01:42:11,174
సాఫ్ట్వేర్ తయారు
ఏమి తప్పు జరిగింది మరియు ఎందుకు

1992
01:42:11,174 --> 01:42:13,590
వారు ద్వారా చూడండి తద్వారా
వారి పత్రరచన లేక కోడ్,

1993
01:42:13,590 --> 01:42:15,465
మరియు బయటకు దొరుకుతుందని ఏమి
లోపం వాస్తవానికి అర్థం.

1994
01:42:15,465 --> 01:42:18,400
ఇది సాధారణంగా కాదు
మాకు ఉపయోగపడుతుంది అంతం వినియోగదారులు.

1995
01:42:18,400 --> 01:42:20,550
>> కానీ ప్రధాన రాబడి 0, అన్ని బాగా ఉన్నప్పుడు.

1996
01:42:20,550 --> 01:42:23,770
మరియు మీరు పేర్కొన్న లేకపోతే
ప్రధాన తిరిగి ఉండాలి ఏమి,

1997
01:42:23,770 --> 01:42:26,950
అది కేవలం స్వయంచాలకంగా రెడీ
మీరు కోసం 0 తిరిగి.

1998
01:42:26,950 --> 01:42:30,870
కానీ ఏదో తిరిగి
వేరే వాస్తవానికి ఉపయోగపడుతుంది.

1999
01:42:30,870 --> 01:42:34,660
>> ఈ చివరి కార్యక్రమంలో, నాకు తెలియజేయండి
ముందుకు వెళ్లి ఈ exit.c కాల్,

2000
01:42:34,660 --> 01:42:38,630
నేటి చివరి పరిచయం
లోపం కోడ్ అంటారు విషయాలు.

2001
01:42:38,630 --> 01:42:42,930
నాకు ముందుకు వెళ్లి ఉన్నాయి లెట్ మా
తెలిసిన ఫైళ్లు టాప్, Int ప్రధాన.

2002
01:42:42,930 --> 01:42:49,500
మరియు ఈ సమయంలో, యొక్క Int argc, తెలియజేసేలా
స్ట్రింగ్ argv, మరియు నా బ్రాకెట్స్

2003
01:42:49,500 --> 01:42:50,836
అది యెరే నందలి అని చెప్పేందుకు.

2004
01:42:50,836 --> 01:42:52,460
ఆపై నాకు కేవలం ఒక తెలివి తనిఖీ.

2005
01:42:52,460 --> 01:42:56,640
ఈ సమయంలో, argc లేనప్పుడు
సమానంగా 2, అప్పుడు మీరు ఏమి?

2006
01:42:56,640 --> 01:42:57,520
మర్చిపోండి.

2007
01:42:57,520 --> 01:43:03,170
నేను ఆ చెప్పటానికి వెళ్ళిపోతున్నాను, హే, వినియోగదారు,
మీరు లేని కమాండ్ లైన్ వాదన

2008
01:43:03,170 --> 01:43:04,210
బాక్ స్లాష్ n.

2009
01:43:04,210 --> 01:43:05,230
>> ఆపై అంతే.

2010
01:43:05,230 --> 01:43:06,130
నేను నిష్క్రమించడానికి కావలసిన.

2011
01:43:06,130 --> 01:43:11,030
నేను preemptively వెళ్ళిపోతున్నాను,
మరియు ముందుగానే నిజంగా, తిరిగి

2012
01:43:11,030 --> 01:43:12,810
సంఖ్య 1 కంటే ఇతర ఏదైనా.

2013
01:43:12,810 --> 01:43:15,360
మొదటి కోసం విలువ వెళ్ళండి
ఇదే లోపం 1 ఉంది.

2014
01:43:15,360 --> 01:43:17,860
మీరు కొన్ని ఇతర తప్పుడు ఉంటే
జరగవచ్చు ఆ పరిస్థితిలో,

2015
01:43:17,860 --> 01:43:21,390
మీరు తిరిగి 2 చెబుతున్నారు లేదా 3 తిరిగి ఉండవచ్చు, లేదా
ఇంకా ప్రతికూల 1 లేదా ప్రతికూల 2.

2016
01:43:21,390 --> 01:43:23,750
>> ఈ నిష్క్రమణ కోడ్లు
ఆ ఉంటాయి, సాధారణంగా,

2017
01:43:23,750 --> 01:43:27,770
లేదా ప్రోగ్రామర్ ఉపయోగపడుతుంది,
సాఫ్ట్వేర్ షిప్పింగ్ చేసే సంస్థ.

2018
01:43:27,770 --> 01:43:30,500
అయితే వాస్తవానికి అంతే
0 కానప్పుడు ముఖ్యం ఏమిటి.

2019
01:43:30,500 --> 01:43:34,310
కాబట్టి ఈ ప్రోగ్రామ్ లో ఉంటే, నేను మీరు
హామీ ఈ కార్యక్రమం మాత్రమే

2020
01:43:34,310 --> 01:43:38,190
యూజర్ నాకు అందిస్తుంది పనిచేస్తుంది
రెండు యొక్క ఒక వాదన లెక్కింపు తో,

2021
01:43:38,190 --> 01:43:42,880
కార్యక్రమం యొక్క పేరు, మరియు కొన్ని ఇతర
పదం, నేను ఈ క్రింది విధంగా ఎక్కువ అమలు చేయవచ్చు

2022
01:43:42,880 --> 01:43:46,110
printf నానుడి వినియోగదారు మీద అరుస్తుంటారు,
తప్పిపోయిన కమాండ్ లైన్ వాదన,

2023
01:43:46,110 --> 01:43:46,970
1 తిరిగి.

2024
01:43:46,970 --> 01:43:49,940
కేవలం వెంటనే రెడీ
కార్యక్రమం నిష్క్రమించాడు.

2025
01:43:49,940 --> 01:43:55,840
>> argc సమానం చేస్తేనే 2 మేము డౌన్ పొందుతారు
ఇక్కడ, నేను చెప్పడానికి వెళుతున్న సమయంలో,

2026
01:43:55,840 --> 01:44:00,410
హలో శాతం లు, బాక్ స్లాష్ n, ఇది argv1.

2027
01:44:00,410 --> 01:44:03,827
ఇతర మాటలలో, నేను రెడీ
argv 0 తర్వాత వెళ్ళడం లేదు,

2028
01:44:03,827 --> 01:44:05,410
ప్రోగ్రామ్కు కేవలం పేరు.

2029
01:44:05,410 --> 01:44:09,450
నేను కామా, హలో ప్రింట్ మీరు,
మానవ టైప్ రెండవ పదం.

2030
01:44:09,450 --> 01:44:12,580
మరియు ఈ సందర్భంలో లో
లైన్ 13, అన్ని బాగా ఉంటుంది.

2031
01:44:12,580 --> 01:44:15,920
>> నేను argc 2 అని తెలుసు
తార్కికంగా ఈ కార్యక్రమం నుండి.

2032
01:44:15,920 --> 01:44:17,770
నేను ముందుకు వెళ్లి 0 తిరిగి వెళుతున్న.

2033
01:44:17,770 --> 01:44:21,230
జనాంతికంగా, గుర్తుంచుకోండి
ఈ అలాగే స్క్రాచ్ లో నిజం.

2034
01:44:21,230 --> 01:44:24,760
>> తార్కికంగా, నేను ఈ పని చేయడు
మరియు ఈ పంక్తులు టూకీగా

2035
01:44:24,760 --> 01:44:27,020
ఇక్కడ ఈ వేరే నిబంధన లో కోడ్.

2036
01:44:27,020 --> 01:44:29,420
కానీ ఆ విధమైన వార్తలు
అనవసరంగా నా కోడ్ ఇండెంటింగ్.

2037
01:44:29,420 --> 01:44:31,800
మరియు నేను సూపర్ అనుకున్న
స్పష్టమైన ఉన్నా ఏమి ఆ,

2038
01:44:31,800 --> 01:44:34,670
అప్రమేయంగా, హలో
ఏదో, ముద్రిత అందుకుంటారని

2039
01:44:34,670 --> 01:44:36,050
యూజర్ సహకరిస్తుంది ఉన్నంతకాలం.

2040
01:44:36,050 --> 01:44:39,360
>> కనుక ఇది ఉపయోగించడానికి చాలా సాధారణ వార్తలు
ఒక పరిస్థితి, ఒక ఉంటే,

2041
01:44:39,360 --> 01:44:41,870
కొన్ని తప్పుడు క్యాచ్
పరిస్థితి, మరియు అప్పుడు నిష్క్రమణ.

2042
01:44:41,870 --> 01:44:45,690
ఆపై, చాలా కాలం ఉంది
బాగా, వేరే లేదా,

2043
01:44:45,690 --> 01:44:48,060
కానీ కేవలం కోడ్ కలిగి
బయట, అది ఎందుకంటే

2044
01:44:48,060 --> 01:44:51,060
ఈ సమానం
ప్రత్యేక సందర్భంలో, తార్కికంగా.

2045
01:44:51,060 --> 01:44:54,480
నేను కేవలం, తిరిగి నేను 0
నడిపేవారిని అన్ని బాగా సూచిస్తాయి.

2046
01:44:54,480 --> 01:44:58,480
>> నేను తిరిగి 0 తొలగించిన ఉంటే, అది చేస్తాను
స్వయంచాలకంగా నాకు భావించలేము.

2047
01:44:58,480 --> 01:45:00,890
కానీ ఇప్పుడు నేను తిరిగి నేను
కనీసం ఈ సందర్భంలో ఒకటి,

2048
01:45:00,890 --> 01:45:04,940
నేను మంచి కొలత కోసం, వెళుతున్న మరియు
స్పష్టత, ఈ సందర్భంలో 0 తిరిగి.

2049
01:45:04,940 --> 01:45:09,690
కాబట్టి ఇప్పుడు నాకు ముందుకు వెళ్లి నిష్క్రమణ చేయడానికి వీలు,
ఇది కేవలం వదిలి ఒక పరిపూర్ణ segue ఉంది.

2050
01:45:09,690 --> 01:45:14,401
>> కానీ నిష్క్రమణ తయారు, మరియు నాకు వీడలేదు
ముందుకు ./exit చేయండి నమోదు చేయండి.

2051
01:45:14,401 --> 01:45:16,900
మరియు ప్రోగ్రామ్ నాకు కోప్పడ్డాడు
తప్పిపోయిన కమాండ్ లైన్ వాదన.

2052
01:45:16,900 --> 01:45:18,120
సరే, నాకు సహకరించిన లెట్.

2053
01:45:18,120 --> 01:45:23,810
>> నాకు బదులుగా ./exit తెలియజేసేలా, డేవిడ్, ఇవ్వండి.

2054
01:45:23,810 --> 01:45:25,190
ఇప్పుడు దాని చెప్పారు డేవిడ్ హలో.

2055
01:45:25,190 --> 01:45:27,300
మరియు మీరు సాధారణంగా ఈ చూడండి కాదు.

2056
01:45:27,300 --> 01:45:30,650
>> కానీ అది ఒక ఉంది హాజరవుతారు
Linux లో ప్రత్యేక మార్గం నిజానికి చూడటానికి

2057
01:45:30,650 --> 01:45:34,470
ఏమి నిష్క్రమణ కోడ్ తో ఒక కార్యక్రమం ముగిసింది.

2058
01:45:34,470 --> 01:45:37,184
కొన్నిసార్లు ఒక గ్రాఫికల్ లో
Mac OS లేదా Windows వంటి ప్రపంచ,

2059
01:45:37,184 --> 01:45:40,100
మీరు మాత్రమే ఈ సంఖ్యలు ఉన్నప్పుడు ఒక చూడండి
దోష సందేశం తెరపై బయటకు

2060
01:45:40,100 --> 01:45:41,940
మరియు ప్రోగ్రామర్
మీరు ఆ సంఖ్యను చూపిస్తుంది.

2061
01:45:41,940 --> 01:45:44,773
కానీ మేము ఏ లోపం చూడాలనుకుంటే
సందేశం మేము అది ఇక్కడ ఏమి, ఉంది

2062
01:45:44,773 --> 01:45:48,100
కాబట్టి ./exit, Enter, ముద్రణ
తప్పిపోయిన కమాండ్ లైన్ వాదన.

2063
01:45:48,100 --> 01:45:54,590
>> నేను ఇప్పుడు echo $ ?, చేస్తే ఇది
హాస్యాస్పదమైన గుప్తమైన చూస్తున్న.

2064
01:45:54,590 --> 01:45:56,590
కానీ $?

2065
01:45:56,590 --> 01:45:59,220
మాయా అవతారంలో భాగం
ఆ చెప్పారు హే, కంప్యూటర్,

2066
01:45:59,220 --> 01:46:01,900
చెప్పు ఏమి మునుపటి
కార్యక్రమం యొక్క నిష్క్రమణ కోడ్ ఉంది.

2067
01:46:01,900 --> 01:46:03,410
నేను ఎంటర్ కొట్టాడు.

2068
01:46:03,410 --> 01:46:07,520
ఆ ఎందుకంటే నేను, 1 చూసే నేను
తిరిగి నా ప్రధాన విధి చెప్పారు.

2069
01:46:07,520 --> 01:46:12,310
>> ఇంతలో, నేను డేవిడ్ ./exit లేకపోతే,
ఎంటర్ నొక్కండి నేను చూస్తాను, డేవిడ్ హలో.

2070
01:46:12,310 --> 01:46:16,800
మరియు నేను ఇప్పుడు echo $ లేకపోతే ?, నేను హలో చూడండి 0.

2071
01:46:16,800 --> 01:46:19,080
కాబట్టి ఈ వాస్తవానికి
విలువైన సమాచారం ఉంటుంది

2072
01:46:19,080 --> 01:46:23,420
అంత డీబగ్గర్ సందర్భంలో,
మీరు మానవ, ఆసక్తి చూపేవారు ఎక్కువ.

2073
01:46:23,420 --> 01:46:26,060
కానీ డీబగ్గర్ మరియు ఇతర
కార్యక్రమాలు మేము ఈ సెమిస్టర్ ఉపయోగిస్తాము

2074
01:46:26,060 --> 01:46:29,420
తరచూ ఆ సంఖ్యను పరిశీలిస్తారు,
ఇది విధమైన మరుగునపడుతోంది అయినప్పటికీ

2075
01:46:29,420 --> 01:46:32,780
మీరు దాని కోసం, చూస్తుంది తప్ప
గుర్తించడానికి లేదో ఒక ప్రోగ్రామ్ యొక్క

2076
01:46:32,780 --> 01:46:37,050
అమలు సరైన లేదా తప్పు.

2077
01:46:37,050 --> 01:46:40,450
>> కాబట్టి ఆ వచ్చాము
ఈ రోజు చివరిలో.

2078
01:46:40,450 --> 01:46:43,917
మేము చూడటం ద్వారా నేడు ప్రారంభించండి
డీబగ్గింగ్, మరియు కోర్సు మలుపు

2079
01:46:43,917 --> 01:46:46,750
కూడా, మరియు అప్పుడు మరింత ఆసక్తికరంగా,
సాంకేతికంగా హుడ్ కింద

2080
01:46:46,750 --> 01:46:49,490
ఏమి వద్ద తీగలను కొనసాగుతుంది, ఉన్నాయి
వారం మేము కేవలం మంజూరు కోసం పట్టింది,

2081
01:46:49,490 --> 01:46:51,900
మరియు ఖచ్చితంగా తీసుకువెళ్ళాడు
స్క్రాచ్ లో మంజూరు చేసింది.

2082
01:46:51,900 --> 01:46:56,040
>> మేము అప్పుడు మేము యాక్సెస్ ఎలా చూశారు
ఒక స్ట్రింగ్ లో విడివిడి అక్షరాలను,

2083
01:46:56,040 --> 01:47:00,310
మళ్ళీ ఒక ఉన్నత స్థాయి పట్టింది
ఎలా well-- చూస్తూ, విషయాలు చూడండి

2084
01:47:00,310 --> 01:47:04,226
మేము వ్యక్తిగత వద్ద పొందడానికి అనుకుంటే
నిర్మాణం వంటి జాబితాలో అంశాలను,

2085
01:47:04,226 --> 01:47:05,850
మేము బహుళ తీగలను అలా కాదు?

2086
01:47:05,850 --> 01:47:08,050
మరియు మేము ఆదేశ పంక్తి వాదనలు తో చేయవచ్చు.

2087
01:47:08,050 --> 01:47:12,800
కానీ ఇక్కడ కేవలం బాక్సులను ఈ చిత్రాన్ని
ఈ సాధారణ ఆలోచన తావు

2088
01:47:12,800 --> 01:47:14,451
వ్యూహం, లేదా ఒక జాబితా, లేదా ఒక సదిశ యొక్క.

2089
01:47:14,451 --> 01:47:16,450
మీద ఆధారపడి
సందర్భంలో, ఈ పదాలు అన్ని

2090
01:47:16,450 --> 01:47:17,880
కొద్దిగా అర్ధాలున్నాయి.

2091
01:47:17,880 --> 01:47:20,060
కాబట్టి సి లో, మేము మాత్రమే చూడాలని
వ్యూహం గురించి మాట్లాడటానికి.

2092
01:47:20,060 --> 01:47:23,840
మరియు ఒక అర్రే ఒక భాగం ఉంది
మెమొరీ, వీరిలో ప్రతి వార్తలు

2093
01:47:23,840 --> 01:47:27,720
అంశాలు తిరిగి, పక్కనే,
తిరిగి, తిరిగి, తిరిగి.

2094
01:47:27,720 --> 01:47:31,970
>> మరియు ఆ అంశాలు సాధారణంగా ఉంటాయి,
అదే రకం, పాత్ర,

2095
01:47:31,970 --> 01:47:35,966
పాత్ర, పాత్ర, పాత్ర, లేదా
స్ట్రింగ్, స్ట్రింగ్, స్ట్రింగ్, స్ట్రింగ్ లేదా Int,

2096
01:47:35,966 --> 01:47:38,600
పూర్ణాంకానికి Int, ఇది ఏమైనా
మేము స్టోర్ ప్రయత్నిస్తున్న.

2097
01:47:38,600 --> 01:47:42,540
కానీ రోజు చివరిలో, ఈ
దానిని సంభావితంగా అనిపిస్తోంది.

2098
01:47:42,540 --> 01:47:44,530
మీరు వేస్తున్నాము మీ
కంప్యూటర్ యొక్క మెమరీ లేదా RAM.

2099
01:47:44,530 --> 01:47:48,590
మరియు మీరు లోకి చెక్కటానికి చేస్తున్నారు
ఒకే తరహా బాక్సులను, ఇవన్నీ

2100
01:47:48,590 --> 01:47:50,920
తిరిగి ఉంటాయి, వెనుకకు
తిరిగి, ఈ విధంగా వెనుకకు.

2101
01:47:50,920 --> 01:47:53,200
>> మరియు గురించి nice ఏది
ఈ ఆలోచన, మరియు నిజానికి

2102
01:47:53,200 --> 01:47:58,580
మేము ఈ విధంగా విలువలు వ్యక్తం చేసే
మా డేటా నిర్మాణాలు మొదటి

2103
01:47:58,580 --> 01:48:02,520
తరగతి లో, మేము ప్రారంభించవచ్చు అంటే
కోడ్ తో సమస్యలను పరిష్కరించటానికి

2104
01:48:02,520 --> 01:48:04,079
ఆ వారం 0 లో అలా అకారణంగా వచ్చింది.

2105
01:48:04,079 --> 01:48:05,870
మీరు ఫోన్ గుర్తుకు వస్తుంది
పుస్తక ఉదాహరణకు,

2106
01:48:05,870 --> 01:48:09,110
మేము ఒక విభజన ఉపయోగిస్తారు జయించటానికి
లేదా ఒక బైనరీ శోధన అల్గోరిథం

2107
01:48:09,110 --> 01:48:13,220
మొత్తం ద్వారా జల్లెడ పట్టు
పేర్లు మరియు సంఖ్యలను యొక్క ఒక సమూహం.

2108
01:48:13,220 --> 01:48:18,220
కానీ మేము భావించబడుతుంది, రీకాల్, ఆ
ఫోన్ బుక్ అప్పటికే క్రమబద్ధీకరించబడింది జరిగినది

2109
01:48:18,220 --> 01:48:21,630
ఎవరో ఇప్పటికే ఉందని
అవ్ట్ పేర్ల జాబితా ఇచ్చారు చిత్రవిచిత్రమైన

2110
01:48:21,630 --> 01:48:24,430
మరియు వాటిని alphabetize ఎలా సంఖ్యల.

2111
01:48:24,430 --> 01:48:26,950
మరియు ఇప్పుడు C లో మేము,
చాలా సామర్థ్యాన్ని కలిగి ఉంటాయి

2112
01:48:26,950 --> 01:48:30,290
విషయాలు బయటకు వేయడానికి,
భౌతికంగా ఒక ఫోన్ బుక్ లో

2113
01:48:30,290 --> 01:48:34,220
కాని వాస్తవంగా ఒక కంప్యూటర్ యొక్క
జ్ఞాపకశక్తి, ఇవ్వగల తదుపరి వారం ఉంటుంది

2114
01:48:34,220 --> 01:48:38,470
తొలి దీన్ని మళ్ళీ పరిచయం
ఒక శ్రేణి మా డేటా నిర్మాణాలు

2115
01:48:38,470 --> 01:48:43,530
కానీ ముఖ్యంగా, అసలు కంప్యూటర్
సైన్స్ అల్గోరిథంలు అమలు

2116
01:48:43,530 --> 01:48:47,720
కోడ్ లో, ఇది మేము నిల్వ చేయవచ్చు
ఈ వంటి నిర్మాణాలలో డేటా,

2117
01:48:47,720 --> 01:48:50,730
ఆపై ఇది రెట్టింపు మొదలు, మరియు
నిజానికి అది తో సమస్యలు పరిష్కరించడంలో,

2118
01:48:50,730 --> 01:48:53,570
మరియు ఆ పైన నిర్మించడానికి,
చివరికి, సి లో కార్యక్రమాలు,

2119
01:48:53,570 --> 01:48:56,730
పైథాన్, JavaScript,
SQL డేటాబేస్ విచారణను?

2120
01:48:56,730 --> 01:48:59,980
>> మరియు మేము ఈ అన్ని చూస్తారు
ఇరికించు వివిధ ఆలోచనలు.

2121
01:48:59,980 --> 01:49:04,100
కానీ ఇప్పుడు కోసం, గుర్తుచేసుకున్నారు
మేము నేడు పరిచయం డొమైన్

2122
01:49:04,100 --> 01:49:06,920
ఈ విషయం ఇక్కడ ఉంది, మరియు
గూఢ లిపి శాస్త్రం యొక్క ప్రపంచ.

2123
01:49:06,920 --> 01:49:11,200
మరుసటి సమస్యలు మీరే మధ్య
గూఢ లిపి శాస్త్రం యొక్క కళ పరిష్కరించే,

2124
01:49:11,200 --> 01:49:13,630
స్క్రాంబ్లింగ్ మరియు డి-స్క్రాంబ్లింగ్
సమాచారం, మరియు ciphering

2125
01:49:13,630 --> 01:49:15,930
మరియు టెక్స్ట్ తెలుసుకొని,
మరియు చివరికి ఊహిస్తూ

2126
01:49:15,930 --> 01:49:18,970
మీరు ఇప్పుడు తెలిసిన ఏమి
హుడ్ కింద ఉంది

2127
01:49:18,970 --> 01:49:21,860
కాబట్టి మీరు చూడండి లేదా అందుకున్నప్పుడు
ఈ సందేశం మీరు

2128
01:49:21,860 --> 01:49:24,060
అది మిమ్మల్ని అర్థమును.

2129
01:49:24,060 --> 01:49:26,740
అన్ని ఈ, మరియు మరింత తదుపరి సమయంలో.

2130
01:49:26,740 --> 01:49:29,890

2131
01:49:29,890 --> 01:49:30,790
>> [వీడియో ప్లేబ్యాక్]

2132
01:49:30,790 --> 01:49:32,970
>> -Mover కేవలం వచ్చారు.

2133
01:49:32,970 --> 01:49:35,146
నేను సందర్శన వెళ్ళి వెళుతున్న
తన కాలేజీ ప్రొఫెసర్.

2134
01:49:35,146 --> 01:49:37,611
YEP.

2135
01:49:37,611 --> 01:49:40,080
హాయ్.

2136
01:49:40,080 --> 01:49:40,660
ఇది నీవు.

2137
01:49:40,660 --> 01:49:44,125

2138
01:49:44,125 --> 01:49:45,110
వేచి!

2139
01:49:45,110 --> 01:49:45,610
డేవిడ్.

2140
01:49:45,610 --> 01:49:53,936

2141
01:49:53,936 --> 01:49:56,060
నేను దొరుకుతుందని దీనికై
మీరు ఏమి జరిగిందో.

2142
01:49:56,060 --> 01:49:58,130
దయచేసి, ఏదైనా సహాయం కాలేదు.

2143
01:49:58,130 --> 01:50:05,020

2144
01:50:05,020 --> 01:50:08,354
మీరు తన కళాశాల ఉన్నాయి
సహవాసి మీరు కాదు?

2145
01:50:08,354 --> 01:50:10,770
మీరు అతన్ని ఉన్నప్పుడు ఉన్నాయి
అతను CS50 ప్రాజెక్ట్ పూర్తి?

2146
01:50:10,770 --> 01:50:13,770

2147
01:50:13,770 --> 01:50:15,765
>> [సంగీతాన్ని]

2148
01:50:15,765 --> 01:50:32,110

2149
01:50:32,110 --> 01:50:33,150
>> -ఆ CS50 ఉంది.

2150
01:50:33,150 --> 01:50:42,690

2151
01:50:42,690 --> 01:50:44,770
>> నేను ఈ స్థానంలో ప్రేమ.

2152
01:50:44,770 --> 01:50:45,854
>> -తినెయ్యి.

2153
01:50:45,854 --> 01:50:47,020
మేము వ్యాపార వెళుతున్న చేస్తున్నాం.

2154
01:50:47,020 --> 01:50:52,120

2155
01:50:52,120 --> 01:50:53,970
>> [END ప్లేబ్యాక్]