1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [MUSIC ప్లే]

3
00:00:11,210 --> 00:00:12,100
>> రాబ్ బోడెన్: అన్ని కుడి.

4
00:00:12,100 --> 00:00:15,620
వీడియో మొదటి, మొదటి విషయం,
ఒక తెలిసిన ముఖం నుండి.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [వీడియో ప్లేబ్యాక్]

7
00:00:22,560 --> 00:00:23,370
>> -అన్ని కుడి.

8
00:00:23,370 --> 00:00:27,150
ఈ CS50, మరియు ఈ ఉంది
వారం మూడు ప్రారంభంలో.

9
00:00:27,150 --> 00:00:29,980
నేను మీతో అక్కడ కాదు క్షమించండి
నేడు, కానీ నాకు పరిచయం అనుమతిస్తుంది

10
00:00:29,980 --> 00:00:32,880
CS50 యొక్క సొంత రాబ్ బోడెన్.

11
00:00:32,880 --> 00:00:33,872
>> [END వీడియో ప్లేబ్యాక్]

12
00:00:33,872 --> 00:00:39,340
>> [చప్పట్లు మరియు చీర్స్]

13
00:00:39,340 --> 00:00:41,277
>> రాబ్ బోడెన్: లో ఫిల్మోగ్రఫీ
వీడియో అద్భుతమైన ఉంది.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
అన్ని కుడి.

16
00:00:47,770 --> 00:00:50,960
కాబట్టి మొదటి, మరొక భోజనం ఉంది.

17
00:00:50,960 --> 00:00:52,330
ఇది 1:15 వద్ద రేపటి.

18
00:00:52,330 --> 00:00:54,480
ఈ శుక్రవారం ఏ భోజనం ఉంది.

19
00:00:54,480 --> 00:00:55,810
ఇది కోరా తో ఉంది.

20
00:00:55,810 --> 00:01:00,190
మరియు టామీ ఒక కానీ, ఇంకా ఇక్కడ కాదు
మాజీ అధిపతి CF ఉంది ప్రజలు,

21
00:01:00,190 --> 00:01:01,530
టామీ మక్.

22
00:01:01,530 --> 00:01:02,730
అందువలన అతను ఒక ఆహ్లాదకరమైన వ్యక్తి.

23
00:01:02,730 --> 00:01:04,819
మీరు వచ్చి ఉండాలి.

24
00:01:04,819 --> 00:01:05,900
>> అన్ని కుడి.

25
00:01:05,900 --> 00:01:11,360
గత వారం, మేము దూరంగా బద్దలు ప్రారంభించారు
ఒక స్ట్రింగ్ నిజంగా ఏమి గురించి.

26
00:01:11,360 --> 00:01:14,830
మేము ప్రారంభం నుంచి తెలిసిన చేసిన
ఇది అక్షరాలు ఒక శ్రేణి యొక్క.

27
00:01:14,830 --> 00:01:18,130
అయితే గత వారం, మేము నిజానికి గాధలను
ఏమి నిజంగా క్రమం అని

28
00:01:18,130 --> 00:01:22,110
అక్షరాలు, బాగా, మేము ఇప్పుడు
అక్షరాలు వ్యూహాలను.

29
00:01:22,110 --> 00:01:26,450
మరియు మేము ఒక స్ట్రింగ్, అది వ్యూహం ఉంది తెలుసు
అక్షరాలు, చాలా చివరిలో,

30
00:01:26,450 --> 00:01:30,920
మేము ఈ ప్రత్యేక శూన్య బైట్ కలిగి, ఈ
బాక్ స్లాష్ 0, చివరికి యొక్క సూచిస్తుంది

31
00:01:30,920 --> 00:01:32,230
స్ట్రింగ్.

32
00:01:32,230 --> 00:01:36,970
>> కాబట్టి ఒక స్ట్రింగ్ యొక్క వ్యూహం ఉంది
అక్షరాలు, కానీ మేము కలిగి కంటే మరింత

33
00:01:36,970 --> 00:01:39,530
కేవలం అక్షరాల యొక్క శ్రేణి,
మేము ఏ వ్యూహం ఉండవచ్చు

34
00:01:39,530 --> 00:01:40,890
మేము విషయం రకం.

35
00:01:40,890 --> 00:01:51,570
కాబట్టి, మీరు గత వారం నుండి రీకాల్,
డేవిడ్ పరిచయం యుగం కార్యక్రమం

36
00:01:51,570 --> 00:01:53,560
నిజంగా త్వరగా.

37
00:01:53,560 --> 00:01:57,010
మేము చేయబోతున్నామని కాబట్టి మొదటి విషయం
, పూర్ణాంకం కోసం వినియోగదారు అడగండి

38
00:01:57,010 --> 00:01:58,800
గదిలో ప్రజల సంఖ్య.

39
00:01:58,800 --> 00:02:01,260
మేము ఆ పూర్ణాంక ఒకసారి,
మేము వ్యూహం ప్రకటించారు చేస్తున్నారు.

40
00:02:01,260 --> 00:02:02,890
ఈ బ్రాకెట్ సింటాక్స్ గమనించండి.

41
00:02:02,890 --> 00:02:04,540
మీకు అలవాటుపడతారు చూడాలని.

42
00:02:04,540 --> 00:02:09,430
>> కాబట్టి మేము పూర్ణాంకాల వ్యూహం ప్రకటించారు చేస్తున్నారు
వయస్సు అని, మరియు n ఉన్నాయి

43
00:02:09,430 --> 00:02:12,080
ఈ శ్రేణి లో పూర్ణాంకాల.

44
00:02:12,080 --> 00:02:16,480
ఇక్కడే కాబట్టి ఈ నమూనా, ఈ 4 పూర్ణాంకానికి
నేను ప్లస్, నేను కంటే తక్కువ n ఉంది, 0 సమానం

45
00:02:16,480 --> 00:02:20,580
ప్లస్, కూడా ఒక నమూనా అని అన్నారు
మీరు చాలా ఉపయోగిస్తారు అని.

46
00:02:20,580 --> 00:02:24,000
ఇది చాలా చక్కని మీరు ఎలా ఎందుకంటే
ఎల్లప్పుడూ శ్రేణుల మీద iterate వెళ్లి.

47
00:02:24,000 --> 00:02:26,330
కాబట్టి n అని గుర్తుంచుకోండి
మా శ్రేణి పొడవు.

48
00:02:26,330 --> 00:02:32,120
మరియు ఇక్కడ, మేము పదేపదే అడుగుతున్నారు
గదిలో వ్యక్తి నేను వయస్సు కోసం.

49
00:02:32,120 --> 00:02:36,640
>> ఈ తరువాత, మేము ఓడిపోవుట, మరియు సంసార కోసం
అనియత కారణం, మేము అప్పుడు

50
00:02:36,640 --> 00:02:40,220
వారు వెళుతున్న ఎలా పాత ప్రింట్
ఇప్పుడు ఒక సంవత్సరం ఉండాలి.

51
00:02:40,220 --> 00:02:49,980
మరియు ఆ ప్రోగ్రామ్ను అమలు, లెట్స్
, వయస్సు తయారు స్లాష్ వయస్సు డాట్.

52
00:02:49,980 --> 00:02:53,010
కాబట్టి గదిలో ప్రజల సంఖ్య,
యొక్క మూడు ఉన్నాయి అని పిలవబడు.

53
00:02:53,010 --> 00:02:59,880
మరియు, మొదటి వ్యక్తి 13, చెప్పడానికి
తదుపరి 26, మరియు గత 30.

54
00:02:59,880 --> 00:03:05,080
కాబట్టి అప్పుడు ఆ మూడు పైగా iterate చేస్తాము
ప్రజలు, 14 27 మరియు 31 ప్రింట్.

55
00:03:05,080 --> 00:03:16,060
>> కాబట్టి గుర్తు మేము ఒక ప్రకటిస్తాయి
పరిమాణం n యొక్క శ్రేణి, ఆ మార్కెట్లు

56
00:03:16,060 --> 00:03:19,950
అర్రే, అర్రే విలువలు మరియు
సూచికలు 0, 1, 2, అన్ని మార్గం

57
00:03:19,950 --> 00:03:21,680
అప్ n మైనస్ 1.

58
00:03:21,680 --> 00:03:26,255
కాబట్టి మేము చెప్పాడు మూడు ప్రజలు ఉన్నాయి
గదిలో, మరియు మేము ఇక్కడ ఉంచారు

59
00:03:26,255 --> 00:03:29,850
ఈ ద్వారా మొదటి పునరుక్తి
లూప్, నేను 0 అన్నారు.

60
00:03:29,850 --> 00:03:31,650
కాబట్టి ఇండెక్స్ 0.

61
00:03:31,650 --> 00:03:34,540
మేము మొదటి కేటాయించి
యూజర్ ప్రవేశిస్తుంది వయస్సు.

62
00:03:34,540 --> 00:03:38,870
తరువాత ఒక లో, మేము ఎంటర్ చేస్తున్నారని
రెండవ n యూజర్ ప్రవేశిస్తుంది, మరియు లో

63
00:03:38,870 --> 00:03:40,580
రెండు, గత n పక్కన.

64
00:03:40,580 --> 00:03:44,200
>> కాబట్టి గమనించి ఆ పరిమాణం యొక్క వ్యూహం
మూడు ఏదైనా లేదు

65
00:03:44,200 --> 00:03:46,040
ఇండెక్స్ మూడు.

66
00:03:46,040 --> 00:03:49,036
ఈ చెల్లదు.

67
00:03:49,036 --> 00:03:50,250
అన్ని కుడి.

68
00:03:50,250 --> 00:03:55,136
కాబట్టి, తిరిగి వెళ్ళటం.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
కాబట్టి ఇప్పుడు మేము శ్రేణితో డీల్ చేసిన,
మేము కొన్ని పరిచయాన్ని కలిగి.

71
00:04:01,590 --> 00:04:03,780
ఇప్పుడు కమాండ్ వెళ్ళటానికి చూడాలని
ఉంటాయని లైన్ వాదనలు,

72
00:04:03,780 --> 00:04:05,890
ఈ సమస్య సెట్ అందంగా సంబంధిత.

73
00:04:05,890 --> 00:04:09,670
>> కాబట్టి ఇప్పుడు వరకు, చేసినప్పుడు మీరు చేసిన
మీ ప్రధాన నిర్ధారించారు, ఉన్నాను

74
00:04:09,670 --> 00:04:11,230
Int ప్రధాన గర్జన చెప్పారు.

75
00:04:11,230 --> 00:04:14,070
కాబట్టి గర్జన కేవలం అంటే
మేము ఏ ప్రయాణిస్తున్న లేదు

76
00:04:14,070 --> 00:04:16,440
ఈ ఫంక్షన్ కు వాదనలు.

77
00:04:16,440 --> 00:04:19,190
ఇప్పుడు మేము ప్రధాన చూడండి చూడాలని
కొన్ని వాదనలు పడుతుంది.

78
00:04:19,190 --> 00:04:22,470
ఇక్కడ మేము argc పూర్ణాంకానికి కాల్
మరియు స్ట్రింగ్ argv బ్రాకెట్లలో.

79
00:04:22,470 --> 00:04:26,930
బ్రాకెట్లలో, మరోసారి, సూచిస్తూ
మేము శ్రేణితో వ్యవహరించే చేస్తున్న.

80
00:04:26,930 --> 00:04:31,850
ఇక్కడ, స్ట్రింగ్ argv బ్రాకెట్లలో, మేము
తీగలను యొక్క వ్యూహం వ్యవహరించే.

81
00:04:31,850 --> 00:04:35,360
కాబట్టి argc, సూచిస్తున్నాయి వెళుతున్న
మేము చేసిన ఎన్ని వాదనలు

82
00:04:35,360 --> 00:04:37,580
ఈ కార్యక్రమం విధించాయి.

83
00:04:37,580 --> 00:04:46,050
మరియు, ఆ ఏమి చూడటానికి
యొక్క ఈ దగ్గరగా తెలియజేయండి.

84
00:04:46,050 --> 00:04:46,490
>> OK.

85
00:04:46,490 --> 00:04:50,790
కాబట్టి ఇప్పుడు వరకు, మేము ప్రతి అమలు చేసిన
డాట్ స్లాష్ వయస్సు కార్యక్రమం.

86
00:04:50,790 --> 00:04:55,250
మేము కూడా, కమాండ్ లైన్ వద్ద, గత
వాదనలను, ఈ పదం, ఆదేశం

87
00:04:55,250 --> 00:04:56,550
పంక్తి వాదనలు.

88
00:04:56,550 --> 00:04:59,760
కాబట్టి మొదటి వాదన, హలో వరల్డ్.

89
00:04:59,760 --> 00:05:03,350
ఇక్కడ, argc మూడు ఉంటుంది.

90
00:05:03,350 --> 00:05:07,720
ఇది వాదనలు జమీందారుల
కమాండ్ లైన్ వద్ద.

91
00:05:07,720 --> 00:05:12,840
Argc, కనీసం 1 నుండి డాట్
, జంట మధ్య స్లాష్, ఒకటి గా లెక్కింపబడుతుంది

92
00:05:12,840 --> 00:05:14,490
ఆదేశ పంక్తి వాదనలు.

93
00:05:14,490 --> 00:05:17,010
>> అప్పుడు హలో మొదటి ఉంది.

94
00:05:17,010 --> 00:05:20,460
డాట్ స్లాష్ వయస్సు అప్పుడు, జేరోయేత్ ఉంటే
హలో మొదటి, మరియు ప్రపంచ

95
00:05:20,460 --> 00:05:22,830
రెండవ కమాండ్ లైన్ వాదన.

96
00:05:22,830 --> 00:05:29,490
కాబట్టి స్ట్రింగ్ argv, మేము చూడండి చూడాలని,
తీగలను, డాట్ స్లాష్ కలిగి

97
00:05:29,490 --> 00:05:33,830
వయస్సు, హలో, మరియు ప్రపంచ.

98
00:05:33,830 --> 00:05:38,945
దావీదు యొక్క అభ్యర్థన, మేము చేయబోతున్నామని
ఆ పరిచయం ఒక వీడియో ప్లే.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [వీడియో ప్లేబ్యాక్]

101
00:05:43,890 --> 00:05:46,240
>> అప్ ఉన్నాను కార్యక్ ఇప్పుడు వరకు
రాసిన, మేము డిక్లేర్ చేసిన

102
00:05:46,240 --> 00:05:48,500
ప్రధాన వంటి Int ప్రధాన గర్జన.

103
00:05:48,500 --> 00:05:51,170
మరియు అన్ని ఈ సమయంలో, శూన్యమైన ఉంది
కేవలం పేర్కొనడం జరిగింది అని

104
00:05:51,170 --> 00:05:54,430
కార్యక్రమం ఏ తీసుకోదు
ఆదేశ పంక్తి వాదనలు.

105
00:05:54,430 --> 00:05:57,750
ఒక వినియోగదారు ఒక నడుస్తుంది ఇతర మాటలలో, లో
కార్యక్రమం, అతను లేదా ఆమె ఆదేశం అందిస్తుంది

106
00:05:57,750 --> 00:06:01,710
అదనపు వ్రాయడం ద్వారా పంక్తి వాదనలు
పదాలు లేదా పదబంధాలు కార్యక్రమం యొక్క

107
00:06:01,710 --> 00:06:03,000
ప్రాంప్టులో పేరు.

108
00:06:03,000 --> 00:06:06,550
>> బాగా, మీరు మీ కార్యక్రమాన్ని కావలసిన ఉన్నా
ఆదేశ పంక్తి వాదనలు, ఒకటి లేదా పడుతుంది

109
00:06:06,550 --> 00:06:10,540
మరింత పదాలు, మేము స్థానంలో అవసరం
వాదనలు ఒక జంట తో రద్దు.

110
00:06:10,540 --> 00:06:12,200
కాబట్టి యొక్క ఆ తెలియజేసేలా.

111
00:06:12,200 --> 00:06:15,750
Cs50.h. ఉన్నాయి

112
00:06:15,750 --> 00:06:19,360
ప్రామాణిక io.h. చేర్చండి

113
00:06:19,360 --> 00:06:20,760
ప్రధాన Int.

114
00:06:20,760 --> 00:06:26,330
ఇప్పుడు, బదులుగా శూన్యము, నేను వెళుతున్న
ఒక argc అని Int, మరియు ఒక పేర్కొనండి

115
00:06:26,330 --> 00:06:28,780
argv తీగలను శ్రేణి.

116
00:06:28,780 --> 00:06:31,820
ఇప్పుడు, argc మరియు argv ఉంటాయి
కేవలం సమావేశాలు.

117
00:06:31,820 --> 00:06:34,000
>> మేము ఈ వాదనలు అని ఉండవచ్చు
మేము అత్యంత ఏదైనా.

118
00:06:34,000 --> 00:06:37,630
కానీ ముఖ్యమో argc ఉంటుంది
ఒక Int నిర్వచనం ద్వారా ఇది, ఎందుకంటే

119
00:06:37,630 --> 00:06:41,360
వాదన లెక్కింపు కలిగి అన్నారు,
మొత్తం పదాలు సంఖ్య అని

120
00:06:41,360 --> 00:06:43,380
వినియోగదారు అతని లేదా ఆమె ప్రాంప్ట్ వద్ద టైప్ ఉంది.

121
00:06:43,380 --> 00:06:47,910
argv, మరోవైపు, వాదన వెక్టర్, ఉంది
నిజానికి నిల్వ వ్యూహం మాత్రం

122
00:06:47,910 --> 00:06:52,020
యూజర్ యొక్క పదాల అన్ని
తన ప్రాంప్ట్ వద్ద టైప్.

123
00:06:52,020 --> 00:06:54,500
>> యొక్క ఇప్పుడు ఏదో ముందుకు తెలపండి
ఈ ఒకటి లేదా ఎక్కువ తో

124
00:06:54,500 --> 00:06:55,660
ఆదేశ పంక్తి వాదనలు.

125
00:06:55,660 --> 00:07:00,070
ముఖ్యంగా, యొక్క ముందుకు మరియు ముద్రణ వీడలేదు
సంసార పదం రకాల

126
00:07:00,070 --> 00:07:03,960
కార్యక్రమం యొక్క పేరు తర్వాత
ప్రాంప్టులో.

127
00:07:03,960 --> 00:07:04,730
ఓపెన్ బ్రాకెట్.

128
00:07:04,730 --> 00:07:06,240
Close బ్రాకెట్.

129
00:07:06,240 --> 00:07:10,510
Printf శాతం లు బాక్ స్లాష్ మరియు కామా.

130
00:07:10,510 --> 00:07:14,550
ఇప్పుడు నేను printf ఏ విలువ చెప్పడం అవసరం
ఆ హోల్డర్ లోకి ప్రదర్శించాడు.

131
00:07:14,550 --> 00:07:18,600
నేను యూజర్ కలిగి మొదటి పదం మీరు
కార్యక్రమం యొక్క పేరు తర్వాత టైప్,

132
00:07:18,600 --> 00:07:23,130
అందువలన నేను తెలుపుటకు వెళుతున్న
argv బ్రాకెట్ 1, దగ్గరగా

133
00:07:23,130 --> 00:07:24,830
కుండలీకరణములలో సెమికోలన్.

134
00:07:24,830 --> 00:07:27,290
>> ఇప్పుడు, ఎందుకు బ్రాకెట్ 1 మరియు బ్రాకెట్ 0?

135
00:07:27,290 --> 00:07:30,990
బాగా, అది స్వయంచాలకంగా నిల్వ, అవుతుంది
argv లో 0 అన్నారు

136
00:07:30,990 --> 00:07:32,620
కార్యక్రమం యొక్క నిజమైన పేరు.

137
00:07:32,620 --> 00:07:36,180
కాబట్టి మొదటి పదం ఆ యూజర్ రకాల
ప్రోగ్రామ్ యొక్క పేరు ద్వారా, తర్వాత

138
00:07:36,180 --> 00:07:38,990
సమావేశం, మాత్రం
argv 1 నిల్వ.

139
00:07:38,990 --> 00:07:42,380
యొక్క ఇప్పుడు కంపైల్ లెట్ మరియు
ఈ ప్రోగ్రామ్ రన్.

140
00:07:42,380 --> 00:07:47,780
>> Argv 0, డాట్ స్లాష్ argv 0 చేయండి.

141
00:07:47,780 --> 00:07:50,520
ఇప్పుడు ఒక పదం హలో వంటి.

142
00:07:50,520 --> 00:07:51,670
నమోదు చేయండి.

143
00:07:51,670 --> 00:07:53,520
మరియు అక్కడ మేము హలో, అది కలిగి.

144
00:07:53,520 --> 00:07:55,750
>> [END వీడియో ప్లేబ్యాక్]

145
00:07:55,750 --> 00:07:57,000
>> రాబ్ బోడెన్: అన్ని కుడి.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
ఆ Close.

148
00:08:01,230 --> 00:08:16,730
ఆ కార్యక్రమం పరిశీలించి తీసుకున్న
మేము, బాగా, మాకు కేవలం పరిచయం

149
00:08:16,730 --> 00:08:24,710
మేము 0 argv ప్రింట్ ఇప్పుడు, తయారు,, చూపించడానికి
ఇది, argv 0, డాట్ స్లాష్ argv 0 ఏమిటి.

150
00:08:24,710 --> 00:08:30,440
అంచనా కనుక,, అది ముద్రించిన యొక్క
argv 0 ఎందుకంటే, ప్రోగ్రామ్ యొక్క పేరు

151
00:08:30,440 --> 00:08:32,970
ఎల్లప్పుడూ మాత్రం
కార్యక్రమం పేరు.

152
00:08:32,970 --> 00:08:35,640
కానీ యొక్క ఏదో ఒక తెలియజేసేలా
ఆసక్తికరమైన బిట్.

153
00:08:35,640 --> 00:08:42,080
>> కాబట్టి సమస్య సెట్ లో, మీరు ఉంటాం
ఈ ఫంక్షన్, atoi పరిచయం.

154
00:08:42,080 --> 00:08:44,440
కాబట్టి మనం కోసం atoi ఉపయోగించగలను?

155
00:08:44,440 --> 00:08:48,550
ఆ మార్చేందుకు జరగబోతోంది ఒక
పూర్ణాంకం స్ట్రింగ్.

156
00:08:48,550 --> 00:08:53,280
నేను స్ట్రింగ్ పాస్, రెండు మూడు,
atoi కు, ఆ మార్పు వస్తుంది

157
00:08:53,280 --> 00:08:56,910
పూర్ణాంక, ఒక రెండు మూడు.

158
00:08:56,910 --> 00:09:01,480
కాబట్టి మేము మొదటి మార్చేందుకు వెళుతున్న
పూర్ణాంకం కమాండ్ లైన్ వాదన,

159
00:09:01,480 --> 00:09:05,690
ఆపై ఆ పూర్ణాంక ప్రింట్.

160
00:09:05,690 --> 00:09:09,680
>> కాబట్టి ప్రాథమికంగా, మేము రకమైన ఉన్నారు
కేవలం, GetInt reimplementing

161
00:09:09,680 --> 00:09:12,350
పూర్ణాంక ఆదేశం వద్ద ఎంటర్ ఉంది
పంక్తి బదులుగా కార్యక్రమంలో

162
00:09:12,350 --> 00:09:14,560
యింటరాక్టివ్గా.

163
00:09:14,560 --> 00:09:23,170
కాబట్టి అప్పుడు, argv 0 దీనితో యొక్క తెలియజేసేలా
ఇక్కడ అది, మరియు ఆ దగ్గరగా.

164
00:09:23,170 --> 00:09:27,670
కాబట్టి argv 0 పరుగు, యొక్క ప్రవేశించే
పూర్ణాంక, ఒక రెండు మూడు నాలుగు రెండు.

165
00:09:27,670 --> 00:09:30,840
కనుక ఇది, ఒక పూర్ణాంకం ప్రింట్ చేస్తాము
రెండు మూడు నాలుగు రెండు.

166
00:09:30,840 --> 00:09:35,500
ఆ atoi కొన్ని సూక్ష్మబేధాలు ఉన్నాయి
ఇది ఏదైనా గురించి caring ఆపడానికి ఉంటాం

167
00:09:35,500 --> 00:09:39,040
ఒక చెల్లుబాటు అయ్యే సంఖ్యా పాత్ర దాటి,
కానీ ఆ విషయం కాదు.

168
00:09:39,040 --> 00:09:42,870
>> కాబట్టి మీరు ఏమి ఆలోచిస్తాడు
నేను ఇలా చేస్తే?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
లోపంగా.

171
00:09:47,050 --> 00:09:50,410
కాబట్టి ఎందుకు అని?

172
00:09:50,410 --> 00:09:56,060
మీరు మా కార్యక్రమంలో వద్ద తిరిగి చూస్తే, మేము
argv 1, మొదటి వాదన మార్చడానికి

173
00:09:56,060 --> 00:09:59,610
కార్యక్రమం పేరు తరువాత, పూర్ణాంకం.

174
00:09:59,610 --> 00:10:03,350
కానీ ఆమోదం ఎటువంటి వాదన ఉంది
కార్యక్రమం పేరు తరువాత.

175
00:10:03,350 --> 00:10:08,060
ఇక్కడ, మేము ఈ ఒక బగ్గీ అని చూడండి
కార్యక్రమం, నుండి, మేము అమలు ప్రయత్నించినట్లయితే

176
00:10:08,060 --> 00:10:10,530
ఏ వాదనలు లేకుండా,
ఇది కేవలం క్రాష్ చేస్తుంది.

177
00:10:10,530 --> 00:10:16,950
>> మీరు చూస్తారు కాబట్టి మరొక సాధారణ నమూనా
ఏదో వంటి, argc తక్కువ ఉంది ఉంటే

178
00:10:16,950 --> 00:10:21,100
లేదని సూచిస్తూ రెండు, కంటే
కనీసం ప్రోగ్రామ్ పేరు మరియు ఒక

179
00:10:21,100 --> 00:10:29,100
మొదటి వాదన, అప్పుడు మేము ఏదో చేస్తాను
వంటి printf, తగినంత కాదు

180
00:10:29,100 --> 00:10:31,190
ఆదేశ పంక్తి వాదనలు.

181
00:10:31,190 --> 00:10:33,170
ఆ బహుశా ముద్రించడానికి ఒక మంచి ఒకటి కాదు,
ఇది వంటి, బహుశా ఏదో ఉంది

182
00:10:33,170 --> 00:10:35,440
మీరు ఒక పూర్ణాంకం ఎంటర్ చేయాలి
కమాండ్ లైన్ వద్ద.

183
00:10:35,440 --> 00:10:37,450
నేను అక్కడ అది అంతం.

184
00:10:37,450 --> 00:10:39,600
ఆపై 1 తిరిగి.

185
00:10:39,600 --> 00:10:44,740
మా చివరిలో గుర్తుంచుకోవాలి
కార్యక్రమం, మేము తిరిగి 0, ఆ విధమైన

186
00:10:44,740 --> 00:10:47,060
విజయం సూచిస్తుంది.

187
00:10:47,060 --> 00:10:50,940
మరియు ప్రధాన కూడా స్వయంచాలకంగా
మీరు లేకపోతే 0 తిరిగి.

188
00:10:50,940 --> 00:10:55,800
>> ఇక్కడ, మేము సూచించడానికి 1 రీట్యూనింగ్ చేస్తున్నారు
ఆ విజయం కాదు.

189
00:10:55,800 --> 00:11:01,000
మరియు మీకు కావలసిన తిరిగి,
కేవలం, 0 విజయం సూచిస్తుంది, మరియు

190
00:11:01,000 --> 00:11:03,390
ఏదైనా వైఫల్యం సూచిస్తుంది.

191
00:11:03,390 --> 00:11:04,855
కాబట్టి యొక్క విషయాల ఈ వెర్షన్ అమలు అనుమతిస్తాయి.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
కాబట్టి ఇప్పుడు, మేము ఒక కమాండ్ లైన్ ఎంటర్ లేకపోతే
వాదన, ఇది సరిగ్గా చెబుతాడని

194
00:11:16,600 --> 00:11:18,290
మాకు, తగినంత కమాండ్ లైన్ కాదు.

195
00:11:18,290 --> 00:11:20,610
వాక్యం పూర్తి చేయని.

196
00:11:20,610 --> 00:11:24,950
ఎల్స్, మేము నిజంగా ఇది ఒక పాస్ ఉంటే,
కార్యక్రమం పూర్తి.

197
00:11:24,950 --> 00:11:27,920
కాబట్టి ఈ మీరు argc ఉపయోగించడానికి ఎలా ఉంది
సంఖ్య ధ్రువీకరించడానికి

198
00:11:27,920 --> 00:11:30,630
కమాండ్ లైన్ వాదనలు
నిజానికి పంపుతారు.

199
00:11:30,630 --> 00:11:39,360
>> కాబట్టి యొక్క ఒక బిట్ మరింత ఈ కార్యక్రమం తెలియజేయండి
క్లిష్టమైన, మరియు రెండవ చూడండి

200
00:11:39,360 --> 00:11:42,180
విషయాలు మళ్ళా.

201
00:11:42,180 --> 00:11:46,310
కాబట్టి ఇప్పుడు, మేము ప్రింటింగ్ లేదు
మొదటి కమాండ్ లైన్ వాదన.

202
00:11:46,310 --> 00:11:51,210
ఇక్కడ, మేము Int i సమానం నుండి iterating చేస్తున్నారు
0, నేను argc కంటే తక్కువ ప్లస్

203
00:11:51,210 --> 00:11:55,280
ప్లస్, మరియు ముద్రణా argv, ఇండెక్స్ నేను.

204
00:11:55,280 --> 00:11:59,300
కాబట్టి ఈ నమూనా, మళ్ళీ, ఈ అదే
బదులుగా తప్ప ముందు నమూనా,

205
00:11:59,300 --> 00:12:02,600
వేరియబుల్ కాల్
n, మేము argc ఉపయోగిస్తున్నారు.

206
00:12:02,600 --> 00:12:09,520
>> కాబట్టి ఈ ప్రతి సూచిక పైగా iterating ఉంది
శ్రేణి లో, మరియు ప్రతి ముద్రణ

207
00:12:09,520 --> 00:12:11,910
ఆ శ్రేణి లో మూలకం.

208
00:12:11,910 --> 00:12:20,300
కాబట్టి, మేము ఈ ప్రోగ్రామ్ రన్, బాగా,
నేను ఏ ఆదేశ పంక్తి నమోదు చేయలేదు

209
00:12:20,300 --> 00:12:22,540
వాదనలు, కేవలం ప్రింట్లు అది
కార్యక్రమం పేరు.

210
00:12:22,540 --> 00:12:26,053
నేను విషయాలు కొంత ఎంటర్, అది చేస్తాము
ఒక, తన సొంత లైన్ ప్రతి ప్రింట్.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> OK.

213
00:12:32,210 --> 00:12:34,770
కాబట్టి మరింత ఈ ఒక అడుగు తీసుకుందాం.

214
00:12:34,770 --> 00:12:38,890
మరియు బదులుగా ప్రతి వాదన ప్రింటింగ్
తన సొంత లైన్ లో, యొక్క ప్రతి ప్రింట్ తెలియజేయండి

215
00:12:38,890 --> 00:12:42,590
ప్రతి వాదన పాత్ర
తన సొంత లైన్ లో.

216
00:12:42,590 --> 00:12:46,700
కాబట్టి argv అని గుర్తుంచుకోండి
తీగలను యొక్క వ్యూహం.

217
00:12:46,700 --> 00:12:50,960
కాబట్టి ఒక స్ట్రింగ్ ఉంది, కానీ
పాత్రల వ్యూహం?

218
00:12:50,960 --> 00:12:57,140
కాబట్టి ఆ argv నిజంగా అర్థం ఒక
పాత్రల వ్యూహం శ్రేణి.

219
00:12:57,140 --> 00:13:04,920
కాబట్టి ఆ ప్రయోజనాన్ని తీసుకునే,
యొక్క ఇప్పుడు ఈ విస్మరించండి.

220
00:13:04,920 --> 00:13:08,190
యొక్క స్ట్రింగ్ argv 0 పరిశీలిద్దాం.

221
00:13:08,190 --> 00:13:14,170
>> మేము ప్రతి పాత్ర యొక్క తీసుకుని అనుకుంటే
argv 0 తన సొంత లైన్ లో, అప్పుడు నేను

222
00:13:14,170 --> 00:13:19,500
మేము ఉపయోగిస్తున్న నమూనా చేయడానికి, నేను ఉంది
శ్రేణి యొక్క పొడవు కంటే తక్కువ,

223
00:13:19,500 --> 00:13:23,990
ఇక్కడ, యొక్క strlen ఇది, ఆ
నేను చేయాలనుకుంటున్నారా ఏమి లేదు స్ట్రింగ్

224
00:13:23,990 --> 00:13:26,450
లు argv 0 సమానం.

225
00:13:26,450 --> 00:13:30,390
నేను మా యొక్క పొడవు కంటే తక్కువగా ఉంటుంది
ఈ సందర్భంలో వ్యూహం ఇది శ్రేణి,

226
00:13:30,390 --> 00:13:34,410
అక్షరాలు, నేను ప్లస్ ప్లస్.

227
00:13:34,410 --> 00:13:41,040
మేము గత వారం చూసిన మరియు కాబట్టి, అది ఆదర్శ ఉంది
మేము బయట strlen అని తరలిస్తే

228
00:13:41,040 --> 00:13:45,210
పరిస్థితి, నుండి n జోడించడం ఉంటుంది
S యొక్క strlen మేము వెళ్ళి ప్రతి సమయం

229
00:13:45,210 --> 00:13:47,720
లూప్ ద్వారా, మరియు అది ఉంది
మారుతున్న కావడం లేదు.

230
00:13:47,720 --> 00:13:50,230
కాబట్టి మేము ఇక్కడ పైగా n సమానంగా సెట్ చేస్తాము.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> OK.

233
00:13:55,170 --> 00:14:01,320
కాబట్టి ఇప్పుడు, మేము మీద iterating
శ్రేణి లో ప్రతి సూచిక.

234
00:14:01,320 --> 00:14:05,630
కాబట్టి, మేము ప్రతి ప్రింట్ అనుకుంటే
ఆ శ్రేణి, శాతం సి లో పాత్ర

235
00:14:05,630 --> 00:14:06,880
మేము ఉపయోగించడానికి జెండా
అక్షరాలు కోసం.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
ఇప్పుడు ఒక బ్రాకెట్ నేను మాత్రం ఉంది
స్ట్రింగ్, ఇండెక్స్ పాత్ర నేను, అయితే

238
00:14:19,770 --> 00:14:20,970
స్ట్రింగ్ హలో ఉన్నాయి.

239
00:14:20,970 --> 00:14:27,530
అప్పుడు బ్రాకెట్, 0 h అన్నారు s s
1 కాబట్టి ఇ ఉంటుంది, మరియు.

240
00:14:27,530 --> 00:14:30,800
>> కాబట్టి ఇప్పుడు మేము మిళితం మీరు
ఈ రెండు విషయాలు.

241
00:14:30,800 --> 00:14:35,440
మేము ప్రతి పాత్ర ప్రింట్ మీరు
ప్రతి కమాండ్ లైన్ వాదన.

242
00:14:35,440 --> 00:14:38,950
కాబట్టి మేము చూడాలని
ఒక లూప్ యున్న.

243
00:14:38,950 --> 00:14:47,480
మరియు సంప్రదాయకంగా, మొదటి కౌంటర్
నేను, తదుపరి j మాత్రం, n ఉంది

244
00:14:47,480 --> 00:14:54,450
argv నేను strlen ఉంటుంది, నేను
కంటే తక్కువ n, నేను ప్లస్ ప్లస్ ఉంది.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
ఇప్పుడు బదులుగా ముద్రణ argv నేను, కాబట్టి
నేను ఇండెక్స్ అన్నారు argv బ్రాకెట్ -

247
00:15:06,870 --> 00:15:14,280
ఆ i-th కమాండ్ లైన్ చేస్తాడు
వాదన, argv i, j అన్నారు

248
00:15:14,280 --> 00:15:16,925
jth పాత్ర యొక్క ఉంటుంది
i-th వాదన.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
నేను ఇప్పుడు ఇక్కడ ఈ అప్ వదిలించుకోవటం చేస్తాము
మేము ఆ లూప్ ఉంచారు నుండి.

251
00:15:24,810 --> 00:15:33,900
కాబట్టి స్ట్రింగ్ s సమానం సమానం
argv నేను, ఆపై లు బ్రాకెట్ j.

252
00:15:33,900 --> 00:15:36,980
>> Well, మేము ప్రకటించాలని అవసరం లేదు
ఈ వేరియబుల్ s.

253
00:15:36,980 --> 00:15:44,530
బదులుగా, మేము ఈ మిళితం చేస్తాము
మేము ఏ రెండు,, j నేను argv.

254
00:15:44,530 --> 00:15:45,780
>> SPEAKER 1: [వినబడని].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> రాబ్ బోడెన్: గుడ్ కాల్.

257
00:15:49,680 --> 00:15:52,936
కాబట్టి ఈ విభజించబడింది.

258
00:15:52,936 --> 00:15:55,510
నిజానికి ప్రచురింపబడింది ఉంటే, మనం
ఈ గుర్తించాయి.

259
00:15:55,510 --> 00:16:01,210
నేను శ్రద్ధ కాబట్టి కౌంటర్
ఈ ముఖ్యంగా

260
00:16:01,210 --> 00:16:05,410
లూప్ j, ఇటెరేటర్ ఉంది.

261
00:16:05,410 --> 00:16:08,560
కాబట్టి మీరు సమస్యలను రన్ ఉండేది,
బహుశా ఒక అనంతమైన లూప్, మేము

262
00:16:08,560 --> 00:16:09,540
స్థిర లేదు.

263
00:16:09,540 --> 00:16:12,220
మేము కూడా మాట్లాడటం ఎందుకు ఆ
ఈరోజు డీబగ్గింగ్.

264
00:16:12,220 --> 00:16:13,120
>> OK.

265
00:16:13,120 --> 00:16:15,240
కాబట్టి యొక్క ఈ అమలు అనుమతిస్తాయి.

266
00:16:15,240 --> 00:16:21,200
మరియు యొక్క అసలైన ప్రత్యేక printf జోడించడానికి అనుమతిస్తుంది
ఇక్కడే కేవలం ముద్రిస్తుంది ఆ

267
00:16:21,200 --> 00:16:27,480
ఈ అంటే నుండి మరొక లైన్, మేము
అమలు, ఒక ఖాళీ అక్కడ ఉంటాం

268
00:16:27,480 --> 00:16:31,830
ప్రతి పాత్ర యొక్క మధ్య లో లైన్
ప్రతి కమాండ్ లైన్ వాదన.

269
00:16:31,830 --> 00:16:33,448
బాగా, మేము అర్థం చూస్తారు.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
Oop.

272
00:16:37,790 --> 00:16:39,870
కొన్ని బగ్ వచ్చింది.

273
00:16:39,870 --> 00:16:42,860
లోపం పరిపూర్ణంగా ప్రకటించారు
లైబ్రరీ ఫంక్షన్ strlen.

274
00:16:42,860 --> 00:16:51,630
>> కాబట్టి మా కార్యక్రమం తిరిగి వెళ్ళడం, నేను
string.h ఉన్నాయి హాష్ మర్చిపోయారు.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
కాబట్టి string.h అన్నారు
ఉపయోగించడమనేది శీర్షికా ఫైలును

277
00:16:57,730 --> 00:16:58,980
ఫంక్షన్ strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
OK, కూర్చింది.

280
00:17:06,060 --> 00:17:09,109
ఇప్పుడు, యొక్క అమలు అనుమతిస్తాయి.

281
00:17:09,109 --> 00:17:10,930
కాబట్టి ఆ.

282
00:17:10,930 --> 00:17:17,790
ఇది ప్రింట్ వెళుతున్న మా
కార్యక్రమం పేరు, హలో వరల్డ్.

283
00:17:17,790 --> 00:17:23,510
ఇది ప్రతి, ప్రతి విషయం ముద్రించడానికి జరగబోతోంది
తన సొంత లైన్ లో పాత్ర,.

284
00:17:23,510 --> 00:17:24,540
OK.

285
00:17:24,540 --> 00:17:30,625
>> కాబట్టి యొక్క వాస్తవానికి ఈ తీసుకుందాం
మరొక్క అడుగు.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
మరియు బదులుగా string.h ఉపయోగించి, లెట్స్
మేము మా సొంత అమలు కావలసిన ఎలా గురించి ఆలోచించటం

288
00:17:39,700 --> 00:17:41,420
strlen ఫంక్షన్.

289
00:17:41,420 --> 00:17:45,600
నేను వెంటనే ఇస్తాము
ఒక ఫంక్షన్ సంతకం.

290
00:17:45,600 --> 00:17:52,900
కాబట్టి యొక్క my_strlen లో కాల్, మరియు అది ఉంది
ఒక వాదన వంటి స్ట్రింగ్ తీసుకుంటున్నానని,

291
00:17:52,900 --> 00:17:57,220
మరియు మేము తిరిగి వచ్చింది
ఆ స్ట్రింగ్ యొక్క పొడవు.

292
00:17:57,220 --> 00:18:03,430
కాబట్టి, ఆ వ్యక్తి?

293
00:18:03,430 --> 00:18:04,990
అవును.

294
00:18:04,990 --> 00:18:06,740
OK.

295
00:18:06,740 --> 00:18:12,900
కాబట్టి ముందు స్లయిడ్ నుండి గుర్తున్నది
, గత వారం నుండి కూడా అని ఒక

296
00:18:12,900 --> 00:18:18,890
అక్షరాలు శ్రేణి, బాగా, ఒక స్ట్రింగ్,
కాబట్టి యొక్క ఈ మా స్ట్రింగ్ s అంటారు.

297
00:18:18,890 --> 00:18:29,870
కాబట్టి s స్ట్రింగ్ ఉంటే, హలో, అప్పుడు,
H-E-L-L-O, మెమరీ లో, ఆ చేస్తాడు

298
00:18:29,870 --> 00:18:35,610
ఈ బాక్ స్లాష్, మరియు
0 పాత్ర.

299
00:18:35,610 --> 00:18:39,170
>> కాబట్టి మేము ఎలా s యొక్క పొడవు వస్తుందా?

300
00:18:39,170 --> 00:18:43,190
బాగా, ట్రిక్ ఈ అన్వేషిస్తుంది
0 పాత్ర, ఈ శూన్య ప్రతిక్రియలో

301
00:18:43,190 --> 00:18:44,380
టెర్మినేటర్.

302
00:18:44,380 --> 00:18:50,270
కాబట్టి అల్గోరిథం ఉండబోతుంది
కొన్ని లాగ

303
00:18:50,270 --> 00:18:51,510
తగినంత పాత్రలు -

304
00:18:51,510 --> 00:18:56,180
యొక్క ఈ చేతి కొన్ని ప్రాతినిధ్యం వివరించారు
కౌంటర్, యొక్క ఈ Int పొడవు కాల్.

305
00:18:56,180 --> 00:19:00,060
కాబట్టి, ఇక్కడ నుండి మొదలు, మేము ఉన్నాము
మా స్ట్రింగ్ పైగా iterate వెళ్లి.

306
00:19:00,060 --> 00:19:04,100
>> కాబట్టి, ఇది H మొదటి పాత్ర,
మరియు అది తిరిగి కాబట్టి, 0 స్లాష్ కాదు

307
00:19:04,100 --> 00:19:05,170
పొడవు 1 ఉంది.

308
00:19:05,170 --> 00:19:08,050
తదుపరి పాత్ర iterate,
E, మరియు అది 0 బ్యాక్స్లాష్ కాదు.

309
00:19:08,050 --> 00:19:09,630
పొడవు 2.

310
00:19:09,630 --> 00:19:10,960
L, 3.

311
00:19:10,960 --> 00:19:11,850
L, 4.

312
00:19:11,850 --> 00:19:13,050
O, 5.

313
00:19:13,050 --> 00:19:16,690
చివరకు, మేము బాక్ స్లాష్ చేరుకోవడానికి
0, అందువలన సాధనాలు, బాగా,

314
00:19:16,690 --> 00:19:17,780
ఈ స్ట్రింగ్ పైగా ఉంది.

315
00:19:17,780 --> 00:19:20,130
కాబట్టి యొక్క 5 తిరిగి తెలియజేయండి.

316
00:19:20,130 --> 00:19:33,630
>> కాబట్టి నిజంగా, మొదటి, ఆ అమలు
నా n పొడవు నా కుడి చేతి, 0 సమానం.

317
00:19:33,630 --> 00:19:36,088
మరియు మేము iterate చూడాలని -

318
00:19:36,088 --> 00:19:38,000
>> SPEAKER 1: [వినబడని]

319
00:19:38,000 --> 00:19:38,640
>> రాబ్ బోడెన్: ఓహ్, కాలుస్తారు.

320
00:19:38,640 --> 00:19:39,870
గుడ్ కాల్.

321
00:19:39,870 --> 00:19:42,680
బూమ్.

322
00:19:42,680 --> 00:19:44,140
కాబట్టి n పొడవు 0 సమానం.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
కాబట్టి ఇప్పుడు, అయితే లు పొడవు లేదు
సమాన మరియు, బాక్ స్లాష్ 0.

325
00:19:58,310 --> 00:20:04,660
కాబట్టి, ఈ బాక్ స్లాష్ 0 గుర్తు, అది ఒక ఉంది
అసలు పాత్ర, మరియు అది సూచిస్తుంది

326
00:20:04,660 --> 00:20:05,820
స్ట్రింగ్ ముగింపు.

327
00:20:05,820 --> 00:20:09,850
కేవలం వంటి, కూడా, బాక్ స్లాష్
n అసలు పాత్ర.

328
00:20:09,850 --> 00:20:14,040
బ్యాక్స్లాష్ 0 సూచించడానికి అన్నారు
మా స్ట్రింగ్ ముగింపు.

329
00:20:14,040 --> 00:20:15,414
నేను అక్కడ ఉంచారు లేదు.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
మరియు పొడవు ద్వారా సూచిక లు కాదు
శూన్య టెర్మినేటర్ సమానంగా, అప్పుడు

332
00:20:25,620 --> 00:20:27,130
మేము పొడవు పెంచడం చూడాలని.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
కాబట్టి అప్పుడు మా కార్యక్రమం చివరిలో,
పొడవు చివరికి అన్నారు

335
00:20:34,880 --> 00:20:37,610
ఈ సందర్భంలో 5 ఉంటుంది.

336
00:20:37,610 --> 00:20:39,210
మరియు మేము పొడవు తిరిగి చేస్తాము.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> OK.

339
00:20:43,530 --> 00:20:48,290
కాబట్టి ఇప్పుడు డౌన్ ఇక్కడ, నేను లేదు
my_strlen చేయండి.

340
00:20:48,290 --> 00:20:50,700
నిర్థారించడానికి కంపైల్ లెట్
అన్నీ సరిగ్గా నడుస్తుంది.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
నేను 2 లో చేస్తున్న?

343
00:20:58,210 --> 00:21:00,565
లేదా 1 ఉంది?

344
00:21:00,565 --> 00:21:01,940
ఆ చెయ్యాలి.

345
00:21:01,940 --> 00:21:02,690
అన్ని కుడి.

346
00:21:02,690 --> 00:21:08,490
కాబట్టి ఈ argv 2.

347
00:21:08,490 --> 00:21:11,585
ఊహించిన విధంగానే పనిచేస్తుంది అయితే
ఒక నేను దారికొస్తారు

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
అవును.

350
00:21:15,550 --> 00:21:16,760
OK.

351
00:21:16,760 --> 00:21:21,820
విషయాలు ఈ వెర్షన్ లేదు
printf కొత్త తర్వాత పంక్తి, కానీ

352
00:21:21,820 --> 00:21:22,910
ఏ వైవిధ్యం లేదు.

353
00:21:22,910 --> 00:21:23,300
OK.

354
00:21:23,300 --> 00:21:25,780
అంచనా కనుక పని.

355
00:21:25,780 --> 00:21:34,750
>> ఇప్పుడు మేము కూడా ఈ ఒక అడుగు మిళితం చేయవచ్చు
మరింత, ఇక్కడ పేరు నోటీసు, బాగా,

356
00:21:34,750 --> 00:21:38,920
మొదటి, మేము argv యొక్క strlen ఈడ్చడం చేస్తున్నారు
నేను, ఆపై మేము మీద iterating

357
00:21:38,920 --> 00:21:41,450
ఆ స్ట్రింగ్ లో ప్రతి పాత్ర.

358
00:21:41,450 --> 00:21:47,480
బదులుగా ఆ చేయడం వలన, ఏమి మేము
కేవలం వేచి ఈ తర్కం మిళితం

359
00:21:47,480 --> 00:21:50,740
మేము బాక్ స్లాష్ 0 కుడి హిట్ వరకు
లూప్ ఈ లోకి?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Argv i, j చేస్తుంది అందువలన iterate
సమాన కాదు బాక్ స్లాష్ 0.

362
00:22:07,490 --> 00:22:10,680
కాబట్టి యొక్క మొదటి అమలు అనుమతిస్తాయి.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> అన్ని కుడి.

365
00:22:21,180 --> 00:22:27,655
ఇక్కడ, ఈ పరిస్థితి అని -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
స్పష్టమవుతుంది తెలియజేయండి.

368
00:22:40,060 --> 00:22:49,140
కాబట్టి ఇప్పుడు, ఈ మా argv ఉంచబడుతుంది.

369
00:22:49,140 --> 00:22:55,290
కాబట్టి నేను ముందు ఆ కార్యక్రమం నడిచింది,
argv తీగలను యొక్క వ్యూహం ఉంది.

370
00:22:55,290 --> 00:23:03,100
కాబట్టి, నేను డాట్ స్లాష్ argv తో అమలు
2, హలో వరల్డ్, అప్పుడు argv

371
00:23:03,100 --> 00:23:07,650
స్వయంగా argv కోసం, పొడవు 3
సున్నా, హలో, మరియు ప్రపంచ.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> మరియు ఈ సూచికలు ప్రతి లోపలి, ఉంది
స్వయంగా ఈ ఉంటాం పేరు వ్యూహం,

374
00:23:19,660 --> 00:23:23,780
డాట్, ఈ స్లాష్ ఉంటుంది, నేను తెలియదు
కుడి దిశలో ఉంటే, నేను

375
00:23:23,780 --> 00:23:25,680
ఇది ఉంది భావించడం లేదు.

376
00:23:25,680 --> 00:23:30,110
A-R-V డాష్, మరింత స్థలం అవసరం.

377
00:23:30,110 --> 00:23:32,570
యొక్క ఈ శ్రేణి లోకి కట్ లెట్.

378
00:23:32,570 --> 00:23:38,230
A-R-V డాష్ 0, ఆపై బాక్ స్లాష్ 0.

379
00:23:38,230 --> 00:23:43,160
ఆపై గందరగోళము హలో ఉంటుంది.

380
00:23:43,160 --> 00:23:45,910
యొక్క, H-E బాక్ స్లాష్ 0 పిలవబడు.

381
00:23:45,910 --> 00:23:51,130
చివరకు, W-O బాక్ స్లాష్ 0.

382
00:23:51,130 --> 00:23:59,730
>> కాబట్టి మేము కేవలం రాసిన అల్గోరిథం,
వారు ఏమి ఉచ్చులు, కోసం యున్న

383
00:23:59,730 --> 00:24:07,321
డూయింగ్, మేము మొదటి కలిగి
నేను తరువాత j ఎదుర్కోవడానికి.

384
00:24:07,321 --> 00:24:15,206
ఈ న కోడ్ సులభంగా ఉంటుంది
స్క్రీన్, యొక్క ఈ వెళదాం.

385
00:24:15,206 --> 00:24:17,476
OK.

386
00:24:17,476 --> 00:24:24,600
నేను ఆ ఇటెరేటర్ అని గమనించవచ్చు
ప్రతి ఆదేశం మీద iterating

387
00:24:24,600 --> 00:24:25,610
లైన్ వాదన.

388
00:24:25,610 --> 00:24:28,870
మరియు j ఇటెరేటర్ iterating ఉంది
ఆ ప్రతి పాత్ర మీద

389
00:24:28,870 --> 00:24:30,410
కమాండ్ లైన్ వాదన.

390
00:24:30,410 --> 00:24:46,755
కాబట్టి ఈ అంతరాంతర printf చేస్తున్నది
, మేము argv 0 0, printf printf చేశారు ఉంది

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf argv 0 2, 0 3, 0 4, 0
5, 0 6, కానీ ఇప్పుడు, argv 0 7 అన్నారు

392
00:24:58,680 --> 00:25:00,670
సమాన బాక్ స్లాష్ 0.

393
00:25:00,670 --> 00:25:05,730
>> కాబట్టి అప్పుడు మేము లూప్ ఆ నిష్క్రమించడానికి,
మరియు ప్రస్తుతం నేను 1 iterates.

394
00:25:05,730 --> 00:25:10,910
ఇప్పుడు మేము ప్రింట్ చూడాలని
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
బాగా, ఇప్పుడు, నేను చిన్న హలో కట్ నుండి,
argv 1 2 మళ్ళీ అన్నారు

396
00:25:17,040 --> 00:25:18,170
బాక్ స్లాష్ 0.

397
00:25:18,170 --> 00:25:25,050
కాబట్టి, నేను పెంచడం మరియు కొనసాగుతుంది, మరియు
కాబట్టి, వరకు మేము అన్ని ప్రింట్

398
00:25:25,050 --> 00:25:28,580
ప్రపంచ మరియు ఆ మూడు కమాండ్ లైన్ ఉన్నాయి
వాదనలు, మరియు మేము నుండి బయటకు వస్తుంది

399
00:25:28,580 --> 00:25:31,670
అన్నింటి లూప్, మరియు
మా కార్యక్రమం పూర్తి.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
OK.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> ఇక్కడ వచ్చి తెలియజేయండి.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
కాబట్టి మీరు కొన్ని పరిచయాన్ని పొందుతారు చేస్తాము
ఈ ఆదేశ పంక్తి వాదనలు

406
00:25:52,370 --> 00:25:54,460
ప్రత్యేక సమస్య సెట్.

407
00:25:54,460 --> 00:25:56,630
>> ఇప్పుడు, డీబగ్గింగ్.

408
00:25:56,630 --> 00:26:01,680
కాబట్టి మీరు బహుశా ఇప్పటికే వచ్చింది
మీ మునుపటి కొన్ని డీబగ్గింగ్

409
00:26:01,680 --> 00:26:03,120
సమస్య సెట్.

410
00:26:03,120 --> 00:26:08,420
మరియు డీబగ్గింగ్ ఒకటి చాలా సులభమైన మార్గం,
మొదటి, యొక్క ఒక బగ్గీ కార్యక్రమం చూద్దాం.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
, ఈ కార్యక్రమం ద్వారా వాకింగ్
మేము ఒక వినియోగదారుని అభ్యర్థించడం వెళుతున్న

413
00:26:23,830 --> 00:26:29,350
పూర్ణాంక, ఆ పూర్ణాంక సేకరించి, తర్వాత,
ఏకపక్ష, మేము ఒక అయితే లూప్ కలిగి

414
00:26:29,350 --> 00:26:32,280
కేవలం తరుగుదల అన్నారు
ఇది 10 సమానం నేను వరకు.

415
00:26:32,280 --> 00:26:35,820
లెట్ యొక్క కేవలం నేను ఎంటర్ వెబ్ ఊహించుకోవటం
10 కంటే ఎక్కువ పూర్ణాంకం.

416
00:26:35,820 --> 00:26:38,700
ఇది 10 సమానం వరకు నేను తరుగుదల.

417
00:26:38,700 --> 00:26:42,630
>> మరియు అప్పుడు మేము మరొక సమయంలో లూప్ ఉన్నాయి
నేను 0 సమానం కాదు ఉన్నప్పటికీ, మేము, ఆ

418
00:26:42,630 --> 00:26:44,540
3 ద్వారా నేను తరుగుదల అన్నారు.

419
00:26:44,540 --> 00:26:49,790
కాబట్టి మీరు బగ్ ఉద్దేశం చూడండి
ఇక్కడ, ఈ నేను తరుగుదల చేస్తాము ఆ

420
00:26:49,790 --> 00:26:57,010
10 మరియు ఈ సమయంలో లూప్ విల్
1 4 7 10,,, నుండి తరుగుదల నేను,

421
00:26:57,010 --> 00:27:02,880
ప్రతికూల 2, అందువలన న 5 ప్రతికూల, మరియు
ప్రతికూల అనంతం రెడీ నుండి

422
00:27:02,880 --> 00:27:05,920
నిజానికి 0 సమానంగా ఎప్పుడూ.

423
00:27:05,920 --> 00:27:08,610
మరియు తర్వాత ఈ కార్యక్రమం చివరిలో,
మేము ఇది foo చర్య

424
00:27:08,610 --> 00:27:12,130
ముద్రణ మీద వెళ్ళడం నేను.

425
00:27:12,130 --> 00:27:16,520
>> కాబట్టి ఈ, ఒక చిన్న మరియు అల్పమైన కార్యక్రమం
మరియు బగ్ స్పష్టంగా ఉంటుంది,

426
00:27:16,520 --> 00:27:18,790
ముఖ్యంగా తర్వాత నేను
బగ్ ఏమి చెప్పారో.

427
00:27:18,790 --> 00:27:24,840
కానీ ఇక్కడ ఉద్దేశం బాగా, ఈ బలం, ఉంది
నిజానికి కొన్ని లాగా మీ

428
00:27:24,840 --> 00:27:30,040
గత నుండి అత్యాశ నుండి పరిష్కారాలను
సమస్య సెట్, మరియు ఉండవచ్చు మీరు ఉన్నాయి

429
00:27:30,040 --> 00:27:32,800
మీ కార్యక్రమంలో కొన్ని అనంతమైన లూప్,
మరియు మీరు ఏ ఆలోచన కలిగి

430
00:27:32,800 --> 00:27:34,100
అది కలిగించే.

431
00:27:34,100 --> 00:27:38,690
కాబట్టి ఒక చాలా ఉపయోగకరంగా డీబగ్గింగ్ టెక్నిక్
కేవలం printfs జోడించడం

432
00:27:38,690 --> 00:27:40,180
అన్ని మీ కోడ్ పైగా.

433
00:27:40,180 --> 00:27:49,200
>> ఇక్కడ నేను బయట ఒక printf కావలసిన
అయితే లూప్ మొదటి.

434
00:27:49,200 --> 00:27:53,155
మరియు ఇక్కడ నేను ఒక printf కావలసిన,
మరియు నేను నేను ప్రింట్ చేస్తాము.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
లూప్ అయితే నేను కూడా నేను, మొదటి చేస్తాను.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
వెలుపల, రెండవ లూప్ అయితే.

439
00:28:09,040 --> 00:28:12,170
మరోసారి లోపల ప్రింట్
ఇక్కడ, విలువ నేను.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
మరియు యొక్క ఈ అమలు అనుమతిస్తాయి.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> కాబట్టి డాట్ స్లాష్ డీబగ్.

444
00:28:24,800 --> 00:28:25,610
పూర్ణాంకం ఇవ్వండి.

445
00:28:25,610 --> 00:28:28,150
యొక్క 13 తెలియజేసేలా.

446
00:28:28,150 --> 00:28:28,760
మరియు బూమ్.

447
00:28:28,760 --> 00:28:33,300
మేము అనంతం మళ్ళీ వెతికినా అని చూడండి
రెండవ సమయంలో లూప్ లోపల.

448
00:28:33,300 --> 00:28:36,305
కాబట్టి ఇప్పుడు మేము బగ్ ఉంది ఏమి.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
కానీ printf డీబగ్గింగ్, సంపూర్ణ బాగుంది
కానీ మీ కార్యక్రమాలు ఒకసారి

451
00:28:45,610 --> 00:28:50,560
ఇక మరియు మరింత క్లిష్టంగా, ఉన్నాయి
మరింత అధునాతన పరిష్కారాలను

452
00:28:50,560 --> 00:28:51,705
విషయాలు పని విధానం.

453
00:28:51,705 --> 00:28:52,955
కాబట్టి యొక్క ఈ printfs తొలగించడానికి.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
మరియు యొక్క ఖచ్చితంగా నేను కాదు తెలియజేయండి
తగు.

456
00:29:08,896 --> 00:29:09,850
OK.

457
00:29:09,850 --> 00:29:14,180
>> కాబట్టి మేము చూడాలని కార్యక్రమం
పరిచయం అంటారు

458
00:29:14,180 --> 00:29:16,715
GNU డీబగ్గర్ కోసం GDB,.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
Well, వాస్తవానికి, యొక్క కోసం డీబగ్ తొలగించడానికి
రెండవ, మళ్ళీ డీబగ్ చేయడానికి.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
బాగా, నిజానికి మొదటి, మంచి పాఠం
ఆదేశ పంక్తి వాదనలు లో.

463
00:29:34,440 --> 00:29:37,780
ఈ గణగణమని ద్వని చేయు ఆదేశం అని గమనించండి
ప్రతిదీ ఆమోదించింది ఉంది కంపైల్

464
00:29:37,780 --> 00:29:41,300
కమాండ్ లైన్ వద్ద, ఈ
ఆదేశ పంక్తి వాదనలు.

465
00:29:41,300 --> 00:29:46,250
మీరు ఉపయోగిస్తున్న వెళ్తున్నారు కాబట్టి ఎలా
ఆదేశ పంక్తి వాదనలు, మేము

466
00:29:46,250 --> 00:29:51,500
ముందు, మరియు మీరు pset లో రెడీ
2, గణగణమని ద్వని చేయు వాటిని ఉపయోగించి ఎలా ఉంది.

467
00:29:51,500 --> 00:30:00,070
>> కాబట్టి గమనించి ఆ ఈ మొదటి జెండా, డాష్
ggdb3, ఆ మాట్లాడుతూ ఏమి, గణగణమని ద్వని చేయు,

468
00:30:00,070 --> 00:30:03,790
మీరు ఈ ఫైలు సిద్ధం చేయాలి
ఉద్దేశం మేము చివరికి రెడీ

469
00:30:03,790 --> 00:30:05,380
ఇది డీబగ్ అవసరం.

470
00:30:05,380 --> 00:30:13,840
కాబట్టి కాలం మీరు ఆ జెండా కలిగి,
అప్పుడు మేము GDB డీబగ్ చేయవచ్చు.

471
00:30:13,840 --> 00:30:17,380
మరియు అది GNU డీబగ్గర్ ప్రారంభించిన చేస్తాము.

472
00:30:17,380 --> 00:30:22,920
>> కాబట్టి ఆదేశాలను చాలా ఉన్నాయి
మీరు అలవాటుపడతారు అవసరమైన.

473
00:30:22,920 --> 00:30:27,100
మొదటివి మీరు బహుశా చేస్తాము
వెంటనే అవసరమైన ప్రారంభించేవారు.

474
00:30:27,100 --> 00:30:28,200
కాబట్టి ఏమి ప్రారంభించేవారు?

475
00:30:28,200 --> 00:30:30,910
ఇది మా కార్యక్రమం ఆరంభమవుతుంది.

476
00:30:30,910 --> 00:30:36,180
కాబట్టి, కార్యక్రమం, అమలు
పూర్ణాంకం, 13 కోసం మాకు అడుగుతుంది.

477
00:30:36,180 --> 00:30:39,170
అది అనంతం మళ్ళీ వెతికినా వంటి ఉంది
నేను తొలగించబడింది తప్ప, అంచనా

478
00:30:39,170 --> 00:30:40,500
printfs, కాబట్టి మేము కూడా ఆ చూడలేదు.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
సాధారణంగా ముగిసింది.

481
00:30:44,600 --> 00:30:45,850
ఓహ్.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
ఇది చుట్టి అవకాశం ఉంది అన్ని
మార్గం చుట్టూ, తిరిగి - ఆ విస్మరించి.

484
00:30:53,640 --> 00:30:55,170
ఇది సాధారణంగా బయటకు లేదు భావించండి.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
ఆ ఒక క్లిష్టమైన సమాధానం ఉంది.

487
00:31:03,370 --> 00:31:07,890
>> కాబట్టి ఇప్పుడు, చాలా ఉపయోగకరమైన కాదు.

488
00:31:07,890 --> 00:31:11,480
కాబట్టి కేవలం లోపలి మా ప్రోగ్రామ్ను అమలు
ఈ డీబగ్గర్ ఏ మాకు సహాయం లేదు

489
00:31:11,480 --> 00:31:15,610
మేము పూర్తి కాలేదు నుండి మార్గం,
డాట్ GDB బయట నుండి డీబగ్ స్లాష్.

490
00:31:15,610 --> 00:31:21,250
కాబట్టి ఒక కమాండ్ అని
మీరు బహుశా చేస్తాము -

491
00:31:21,250 --> 00:31:22,970
మరియు నేను ఈ విడిచి చేస్తాము.

492
00:31:22,970 --> 00:31:25,850
కంట్రోల్ డి లేదా, పని రెండు విడిచి.

493
00:31:25,850 --> 00:31:29,550
కాబట్టి యొక్క మళ్ళీ తెరవడం అనుమతిస్తాయి.

494
00:31:29,550 --> 00:31:31,130
>> మరో ఆదేశం అని మీరు బహుశా చేస్తాము
వెంటనే కావలసిన

495
00:31:31,130 --> 00:31:33,600
అలవాటుపడతారు బ్రేక్ ఉంది.

496
00:31:33,600 --> 00:31:37,120
కాబట్టి మేము, ఇప్పుడు ప్రధాన బ్రేక్ ఆన్ చేస్తాము
ఆపై నేను వివరించడానికి చేస్తాము.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
బాగా, ఇక్కడ మనం ఒక బ్రేక్ పాయింట్ సెట్ చూడండి
debug.c ఈ లైన్ వద్ద.

499
00:31:46,370 --> 00:31:50,160
కాబట్టి ఏమి విరామం పద్ధతి నేను
అమలు టైప్, కార్యక్రమం అన్నారు

500
00:31:50,160 --> 00:31:53,560
వరకు కొనసాగించమని
నేను ఒక బ్రేక్ పాయింట్ హిట్.

501
00:31:53,560 --> 00:31:59,390
నేను పరుగుల కొట్టాడు, ప్రోగ్రామ్, మొదలవుతుంది
ఆపై వెంటనే దాని వంటి విచ్ఛిన్నం

502
00:31:59,390 --> 00:32:01,940
ప్రధాన విధి ప్రవేశిస్తుంది.

503
00:32:01,940 --> 00:32:06,930
బ్రేక్ ప్రధాన ఏదో అన్నారు
మీరు అందంగా సాధారణంగా చేయండి.

504
00:32:06,930 --> 00:32:11,340
>> ఇప్పుడు, మీరు పరిచయం
కొన్ని ఎక్కువ ఆదేశాలను.

505
00:32:11,340 --> 00:32:14,330
మేము చెప్పాడు చేసే, ఇక్కడ గమనించవచ్చు
ఇది లైన్ 11, వద్ద విరిగింది

506
00:32:14,330 --> 00:32:16,230
printf, పూర్ణాంకం ఇవ్వండి.

507
00:32:16,230 --> 00:32:21,260
కాబట్టి కమాండ్ తదుపరి ఎలా అన్నారు
మేము కోడ్ యొక్క తదుపరి లైన్ వెళ్ళండి.

508
00:32:21,260 --> 00:32:24,810
ఈ మాకు అడుగు అనుమతిస్తుంది అన్నారు
లైన్ ద్వారా మా కార్యక్రమం లైన్ ద్వారా.

509
00:32:24,810 --> 00:32:26,260
తరువాత.

510
00:32:26,260 --> 00:32:29,820
>> ఇప్పుడు 12, మేము చేయబోతున్నామని
పూర్ణ సంఖ్య.

511
00:32:29,820 --> 00:32:30,450
తదుపరి.

512
00:32:30,450 --> 00:32:34,290
మీరు కేవలం మళ్ళీ నొక్కండి ఉంటే, అది చేస్తాము
మీరు చేసింది గత విషయం పునరావృత్తం.

513
00:32:34,290 --> 00:32:36,480
నేను టైప్ లేదు
ప్రతి సమయం.

514
00:32:36,480 --> 00:32:40,100
కాబట్టి పూర్ణాంకం, 13 ఎంటర్.

515
00:32:40,100 --> 00:32:46,940
కాబట్టి ఇప్పుడు, లైన్ 14, నేను ఎక్కువ ఉంది
10 కంటే, మరియు నేను తరువాత చేస్తాను.

516
00:32:46,940 --> 00:32:48,685
మరియు మేము నేను తరుగుదల చూడాలని చూడండి.

517
00:32:48,685 --> 00:32:50,210
కనుక మనం మళ్ళీ నేను తరుగుదల చూడాలని.

518
00:32:50,210 --> 00:32:53,620
>> కాబట్టి ఇప్పుడు, మరొక ఉపయోగకరమైన
కమాండ్ ప్రింట్ ఉంది.

519
00:32:53,620 --> 00:32:55,750
కాబట్టి ప్రింట్ ప్రింట్ అన్నారు
వేరియబుల్ విలువ.

520
00:32:55,750 --> 00:32:57,825
యొక్క విలువ తేవలెను
నేను వేరియబుల్ యొక్క.

521
00:32:57,825 --> 00:32:58,705
యొక్క నేను ప్రింట్ లెట్.

522
00:32:58,705 --> 00:33:00,910
ఇది నేను 11 ఉంది సే అవకాశముంది.

523
00:33:00,910 --> 00:33:03,330
ఇప్పుడు మేము మళ్ళీ అయితే
నేను 10 కంటే ఎక్కువ.

524
00:33:03,330 --> 00:33:05,590
నేను ఇప్పటికీ కంటే ఎక్కువ
ఇది 11 నుండి 10,.

525
00:33:05,590 --> 00:33:06,920
నేను మైనస్ మైనస్.

526
00:33:06,920 --> 00:33:08,250
యొక్క మళ్ళీ నేను ప్రింట్ లెట్.

527
00:33:08,250 --> 00:33:10,950
ఊహించిన విధంగా, ఇది 10 ఉంది.

528
00:33:10,950 --> 00:33:12,510
>> కాబట్టి ఇప్పుడు, తదుపరి.

529
00:33:12,510 --> 00:33:16,250
ఇది తిరిగి పరిస్థితి చేస్తాడు, నేను ఉంది
10 కంటే ఎక్కువ, కానీ నేను, ఇప్పుడు 10

530
00:33:16,250 --> 00:33:20,040
ఇది 10 కంటే ఎక్కువ కాదు, కాబట్టి కాదనీ
ఇది సమయంలో లూప్ బయటకు వస్తాయి.

531
00:33:20,040 --> 00:33:22,220
ఇప్పుడు మేము కోడ్ యొక్క లైనును క్రింద ఉన్నారు.

532
00:33:22,220 --> 00:33:28,750
మరియు మరొక ఆదేశం, జాబితా, కేవలం అన్నారు
మునుపటి మరియు తదుపరి ప్రదర్శించడానికి

533
00:33:28,750 --> 00:33:31,240
లైన్స్ ఆఫ్ కోడ్, లో జంట
కేసు మీరే కోల్పోయింది.

534
00:33:31,240 --> 00:33:35,420
కాబట్టి మేము కేవలం, ఈ సమయంలో లూప్ నిష్క్రమించారు
మరియు ఇప్పుడు మేము ఈ ప్రవేశించాయి

535
00:33:35,420 --> 00:33:37,080
అయితే లూప్, లైన్ 18.

536
00:33:37,080 --> 00:33:39,860
నేను 0 సమానం కాదు ఉన్నప్పటికీ కాబట్టి.

537
00:33:39,860 --> 00:33:46,570
మరియు, తరువాతి, మనం చేస్తాము నేను మైనస్ 3 సమానం, మరియు
గమనించి, ఈ కేవలం కొనసాగించడాన్ని.

538
00:33:46,570 --> 00:33:48,270
మరియు మేము నేను ప్రింట్ చేయవచ్చు.

539
00:33:48,270 --> 00:33:49,990
>> ప్రతి ఆదేశం విధమైన సత్వరమార్గాలు ఉన్నాయి.

540
00:33:49,990 --> 00:33:51,720
కాబట్టి p ప్రింట్ సంక్షిప్తరూపం.

541
00:33:51,720 --> 00:33:53,400
కాబట్టి మేము p నేను '.

542
00:33:53,400 --> 00:33:57,550
కేవలం n పట్టుకుని ఉంచడానికి,
లేదా తదుపరి పనిని.

543
00:33:57,550 --> 00:33:58,340
మళ్ళీ నేను ప్రింట్.

544
00:33:58,340 --> 00:34:00,380
మీరు 167 ప్రతికూల ఇప్పుడు చూడండి.

545
00:34:00,380 --> 00:34:06,030
కాబట్టి ఈ దిగాలుగా, కానీ కాదు
నిజంగా ఎప్పటికీ, మీరు చూసింది నుండి, ఇది

546
00:34:06,030 --> 00:34:09,330
నిజానికి ఏదో ఒక సమయంలో ముగుస్తుంది.

547
00:34:09,330 --> 00:34:15,699
>> కాబట్టి ఆ GDB ప్రారంభమై ఉంది.

548
00:34:15,699 --> 00:34:19,504
కానీ యొక్క GDB వాసనగాని విషయం తెలియజేసేలా.

549
00:34:19,504 --> 00:34:20,754
ఊ, డీబగ్.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
కాబట్టి, ఈ ప్రత్యేక సందర్భంలో,
అనంతమైన లూప్ యొక్క లోపల సంభవించింది

552
00:34:28,534 --> 00:34:30,050
ప్రధాన విధి.

553
00:34:30,050 --> 00:34:35,779
ఇప్పుడు కోసం, కేవలం నేను ఉన్నాను అంగీకరించి
లోకి అనంతమైన లూప్ వెళ్లి

554
00:34:35,779 --> 00:34:37,029
foo ఫంక్షన్.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
ఈ చివరిలో, గుర్తుంచుకోవాలి
కార్యక్రమం, బాగా, దీనిని మొదట

557
00:34:43,730 --> 00:34:46,210
కేవలం ఇది foo, కాల్
నేను ప్రింట్ అన్నారు.

558
00:34:46,210 --> 00:34:51,880
అయితే ఇప్పుడు మేము ఇది, foo చేస్తున్నారు
అది 0 వరకు నేను తరుగుదల, మరియు అన్నారు

559
00:34:51,880 --> 00:34:54,548
ఆ వేరియబుల్ ప్రింట్.

560
00:34:54,548 --> 00:34:55,469
OK.

561
00:34:55,469 --> 00:34:57,970
ఆ సేవ్.

562
00:34:57,970 --> 00:35:00,175
డీబగ్ చేయండి.

563
00:35:00,175 --> 00:35:03,310
ఇప్పుడు, GDB డీబగ్.

564
00:35:03,310 --> 00:35:04,090
OK.

565
00:35:04,090 --> 00:35:10,580
>> నేను రన్ చేస్తే నేను వెళ్ళడం లేదు
నిజానికి ద్వారా అడుగు చేయగలరు నా

566
00:35:10,580 --> 00:35:11,730
కార్యక్రమం లైన్ ద్వారా లైన్.

567
00:35:11,730 --> 00:35:19,820
కాబట్టి యొక్క ప్రధాన వద్ద బ్రేక్ వీలు,
ఆపై అమలు టైప్.

568
00:35:19,820 --> 00:35:28,160
కాబట్టి ఈ ద్వారా వెళ్ళి, printf, ఎంటర్
పూర్ణాంకం, పూర్ణాంక, 13 పొందడానికి.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
కాబట్టి మేము దానికి వీలు ఉంచడానికి వెళుతున్న
ఐ 10 కంటే ఎక్కువ వరకు.

571
00:35:37,490 --> 00:35:42,840
అప్పుడు మేము ద్వారా వస్తాయి చూడాలని
సమయంలో లూప్, మరియు లైన్ ను -

572
00:35:42,840 --> 00:35:44,364
యొక్క ఒక ప్రత్యేక విండోలో ఇది తెరుచుకుంటుంది తెలియజేయండి.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
ఇకపై నేను వచ్చేవరకు కాబట్టి మేము decremented
అప్పుడు 10 కంటే ఎక్కువ, మరియు మేము

575
00:35:53,300 --> 00:35:55,700
foo, విధి అని.

576
00:35:55,700 --> 00:36:01,340
>> సో వాట్ వెంటనే నేను హిట్ జరిగింది
ఫంక్షన్ foo, బాగా, నేను foo అని, మరియు

577
00:36:01,340 --> 00:36:04,030
నేను ఇకపై GDB నియంత్రణ కలిగి.

578
00:36:04,030 --> 00:36:10,230
కాబట్టి వెంటనే నేను ఈ లైన్ వద్ద తదుపరి హిట్,
ఈ జరిగిన వరకు విషయాలు కొనసాగింది,

579
00:36:10,230 --> 00:36:12,400
అక్కడ కార్యక్రమం నిష్క్రమించారు -

580
00:36:12,400 --> 00:36:14,450
అది చివరికి ఉనికిలో లేదు ఊహించుకోవటం.

581
00:36:14,450 --> 00:36:16,390
మీరు ఒక బిట్ నిలిపివేయి చూసింది.

582
00:36:16,390 --> 00:36:22,040
అందుచే నేను నియంత్రణ తగ్గిపోయింది
ఆ సమయంలో కార్యక్రమం?

583
00:36:22,040 --> 00:36:27,540
నేను తరువాత టైప్ చేసినప్పుడు Well, వెళ్తాడు
కోడ్ సాహిత్య తదుపరి లైన్ అని

584
00:36:27,540 --> 00:36:28,850
నిర్వర్తిస్తుంది.

585
00:36:28,850 --> 00:36:35,950
కాబట్టి తర్వాత పంక్తి 21, కోడ్ యొక్క తదుపరి లైన్
ఆ, లైన్ 22 ఉంది నిర్వర్తిస్తుంది

586
00:36:35,950 --> 00:36:38,520
ప్రధాన నుండి నిష్క్రమించే, ఇది.

587
00:36:38,520 --> 00:36:43,810
కాబట్టి నేను వెళ్లాలని మీరు లేదు
కోడ్ యొక్క తదుపరి లైన్ కు.

588
00:36:43,810 --> 00:36:48,170
నేను ఫంక్షన్, foo లోకి వెళ్లాలని మీరు,
ఆపై కూడా ద్వారా అడుగు

589
00:36:48,170 --> 00:36:49,830
కోడ్ యొక్క ఆ పంక్తులు.

590
00:36:49,830 --> 00:36:53,726
>> కాబట్టి ఆ కోసం, మేము ఒక ప్రత్యామ్నాయ కలిగి.

591
00:36:53,726 --> 00:36:56,770
యొక్క ఆ మళ్ళీ విడిచి తెలియజేయండి.

592
00:36:56,770 --> 00:36:58,020
ప్రధాన విడిపోయారు.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
ఊ, 1, తర్వాత తర్వాత, 13, తదుపరి,
తర్వాత తర్వాత, జాగ్రత్తగా,

595
00:37:06,370 --> 00:37:09,820
మేము లైన్ foo హిట్ ముందు.

596
00:37:09,820 --> 00:37:10,520
OK.

597
00:37:10,520 --> 00:37:13,700
>> కాబట్టి ఇప్పుడు, మేము, లైన్ 21 వద్ద ఉన్నారు
మేము foo కాల్.

598
00:37:13,700 --> 00:37:17,100
మేము, తదుపరి టైప్ అనుకుంటారు నుండి
కేవలం ఫంక్షన్ foo కాల్, మరియు

599
00:37:17,100 --> 00:37:18,710
కోడ్ తదుపరి లైన్ వెళ్ళండి.

600
00:37:18,710 --> 00:37:20,840
మనం ఉపయోగించడానికి అడుగు.

601
00:37:20,840 --> 00:37:25,690
కాబట్టి దశ మధ్య తేడా ఉంది
మరియు దశ లోకి వేసింది పేరు తదుపరి,

602
00:37:25,690 --> 00:37:28,190
పని, మరియు తదుపరి వెళుతుంది
ఫంక్షన్ పైగా.

603
00:37:28,190 --> 00:37:32,830
ఇది కేవలం పూర్తిగా అమలు
ఫంక్షన్ మరియు ఉంచుతుంది అన్నారు.

604
00:37:32,830 --> 00:37:37,210
>> కాబట్టి దశ మాకు తీసుకుని అన్నారు
ఫంక్షన్, foo.

605
00:37:37,210 --> 00:37:41,160
మరియు మేము ఇప్పుడు, మేము తిరిగి ఉన్నారు, ఇక్కడ చూడండి
సిద్ధాంతంలో, ఆ ఈ సమయంలో లూప్,

606
00:37:41,160 --> 00:37:44,190
ఎప్పటికీ కొనసాగుతుంది అన్నారు.

607
00:37:44,190 --> 00:37:50,420
మరియు మీరు కూడా లేనప్పుడు దశ, కొట్టినప్పుడు
కాల్ ఒక ఫంక్షన్, అది ఉంది

608
00:37:50,420 --> 00:37:51,720
తదుపరి కి.

609
00:37:51,720 --> 00:37:55,320
మీరు ఒక లైన్ వద్ద ఉన్నప్పుడు కాబట్టి ఇది మాత్రమే అని
దశ ఒక ఫంక్షన్ కాల్

610
00:37:55,320 --> 00:37:56,970
తదుపరి నుండి తేడా అన్నారు.

611
00:37:56,970 --> 00:37:57,930
కాబట్టి దశ ఇక్కడ మాకు తెస్తుంది.

612
00:37:57,930 --> 00:38:02,100
దశ, అడుగు, అడుగు, అడుగు, అడుగు, అడుగు, మరియు
మేము ఎప్పటికీ కేవలం అనంతమైన లూప్ చేస్తాము.

613
00:38:02,100 --> 00:38:06,810
>> కాబట్టి మీరు ఆ అలవాటుపడతారు ఉండవచ్చు మీ
అనంత వలయాలు గుర్తించడం విధంగా, ఉంది

614
00:38:06,810 --> 00:38:08,960
ఈ Enter కీ రమణిని
మీకు కష్టం ఇక్కడ చూడండి.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
అక్కడ అలా మంచి మార్గాలు ఉన్నాయి, కానీ
ఇప్పుడు కోసం, ఆ సంపూర్ణ సరిపోతుంది.

617
00:38:14,780 --> 00:38:17,967
మరియు ఆకృతిని, శైలి అనుగుణంగా
50, నేను ఈ వుండాలి.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
OK.

620
00:38:24,030 --> 00:38:28,400
>> ఒకనాటి గత ఆదేశం పరిచయం.

621
00:38:28,400 --> 00:38:30,810
సరే, సైన్ డీబగ్ GDB తెలియజేయండి

622
00:38:30,810 --> 00:38:35,580
బదులుగా ప్రధాన వద్ద బద్దలు, నేను
foo ఫంక్షన్ కూడా ఉంది

623
00:38:35,580 --> 00:38:39,230
సమస్య, నేను కలిగి కాలేదు కేవలం
, బదులుగా, foo వద్ద బ్రేక్.

624
00:38:39,230 --> 00:38:42,310
యొక్క నేను వద్ద బ్రేక్ చెప్పడానికి లెట్
ప్రధాన మరియు foo రెండు.

625
00:38:42,310 --> 00:38:45,390
కాబట్టి మీరు అనేక బ్రేక్ పాయింట్స్ సెట్ చేయవచ్చు
మీకు కావలసిన.

626
00:38:45,390 --> 00:38:49,230
నేను పరుగుల టైప్ చేసినప్పుడు, ఏమైందా
వద్ద ఆపడానికి -

627
00:38:49,230 --> 00:38:52,180
ooh, నుండి, యొక్క మళ్ళీ కంపైల్ చెయ్యండి లెట్
నేను మార్చివేసింది.

628
00:38:52,180 --> 00:38:55,950
మీరు ఈ లైన్, హెచ్చరిక, మూల చూస్తారు
ఫైలు executable కంటే ఇటీవల ఉంది.

629
00:38:55,950 --> 00:38:59,680
కాబట్టి ఆ నేను ఇక్కడ వెళ్లిన అర్థం
మరియు శైలి అనుగుణంగా ఈ మారిన

630
00:38:59,680 --> 00:39:03,100
50, కానీ నేను మళ్ళీ కంపైల్ లేదు
కార్యక్రమం.

631
00:39:03,100 --> 00:39:04,870
కాబట్టి GDB ఆ యొక్క నాకు తెలుసు చేస్తుంది.

632
00:39:04,870 --> 00:39:10,130
నేను, మళ్ళీ డీబగ్ చేయడానికి, విడిచి చేస్తాము
GDB డీబగ్ హిట్.

633
00:39:10,130 --> 00:39:10,700
OK.

634
00:39:10,700 --> 00:39:12,800
>> కాబట్టి ఇప్పుడు, తిరిగి నేను ఏమి చేయడానికి.

635
00:39:12,800 --> 00:39:15,720
ప్రధాన, విరామం foo బ్రేక్.

636
00:39:15,720 --> 00:39:20,680
ఇప్పుడు నేను అమలు, కాబట్టి ఇది ఉంటే
హిట్స్ వరకు కొనసాగుతుంది వెళ్లి ఒక

637
00:39:20,680 --> 00:39:21,320
బ్రేక్ పాయింట్.

638
00:39:21,320 --> 00:39:24,680
ఆ బ్రేక్ పాయింట్ నిర్మాణము
ప్రధాన వద్ద మొదటి ఒకటిగా.

639
00:39:24,680 --> 00:39:28,630
ఇప్పుడు, బదులుగా తదుపరి చేయడం యొక్క, తర్వాత తర్వాత,
తరువాత, తదుపరి, నేను foo హిట్ వరకు నేను

640
00:39:28,630 --> 00:39:35,230
కొనసాగుతుంది, కొనసాగుతుంది టైప్ చెయ్యవచ్చు
మీరు తొమ్మిదు హిట్ వరకు.

641
00:39:35,230 --> 00:39:37,200
నేను మొదటి పూర్ణాంక ఎంటర్ ఉంటుంది.

642
00:39:37,200 --> 00:39:40,570
నేను హిట్ వరకు కొనసాగుతుంది కొనసాగించు
ఆ ఇది తొమ్మిదు,

643
00:39:40,570 --> 00:39:43,320
foo ఫంక్షన్.

644
00:39:43,320 --> 00:39:50,130
>> మీరు ఒక హిట్ వరకు అమలు అమలు
ఉన్నప్పుడు బ్రేక్ పాయింట్, కానీ మీరు మాత్రమే అమలు టైప్

645
00:39:50,130 --> 00:39:54,060
మీరు, అప్పుడు కార్యక్రమం మొదలు, మరియు చేస్తున్నారు
అప్పటి నుంచి, కొనసాగుటకు ఉంది.

646
00:39:54,060 --> 00:40:01,950
నేను కేవలం ప్రధాన పోగొట్టుకున్నారు మరియు ఉంటే
అప్పుడు నడిచింది, అది విచ్ఛిన్నం చేస్తాము

647
00:40:01,950 --> 00:40:03,670
అప్పుడు ప్రధాన, మరియు కొనసాగుతుంది.

648
00:40:03,670 --> 00:40:10,050
నేను foo ఒక బ్రేక్ పాయింట్ కలిగి, లేదు నుండి
పూర్ణాంక ఎంటర్, తరువాత ఇప్పుడు నేను ఉన్నాను

649
00:40:10,050 --> 00:40:11,380
foo వద్ద బ్రేక్ మాత్రం కాదు.

650
00:40:11,380 --> 00:40:16,318
ఇది కేవలం అనంత చేస్తాడు
అప్పటిదాకా లూప్.

651
00:40:16,318 --> 00:40:17,568
OK.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> కాబట్టి ఆ GDB ఉపోద్ఘాతం ఉంది.

654
00:40:24,420 --> 00:40:27,790
మీరు ఉపయోగించడం ప్రారంభిస్తుంది
మీ సమస్య లో.

655
00:40:27,790 --> 00:40:30,550
ఇది చాలా సహాయకారిగా ఉంటుంది
దోషాలు గుర్తించడానికి.

656
00:40:30,550 --> 00:40:35,280
మీరు నిజంగా కేవలం, లైన్ ద్వారా లైన్, వెళ్ళి ఉంటే
మీ కోడ్ ద్వారా, మరియు ఉంది ఏమి పోల్చడానికి

657
00:40:35,280 --> 00:40:39,740
నిజానికి మీరు ఆశించిన ఏమి తో జరుగుతున్న
జరిగే, అది అందంగా ఉంది

658
00:40:39,740 --> 00:40:41,060
మీ దోషాలు మిస్ కష్టం.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
OK.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> గత వారం డేవిడ్ ఈ తీసుకువచ్చింది
కోసం రహస్య కీ గూఢ లిపి శాస్త్రం stuff

663
00:40:54,040 --> 00:40:59,350
మేము అనుకుంటున్న పేరు మొదటిసారి,
పాస్వర్డ్లను కేవలం నిల్వ మా

664
00:40:59,350 --> 00:41:03,210
కొన్ని సాదా టెక్స్ట్ ఫైల్ లో కంప్యూటర్, పేరు
ఎవరైనా పైగా మరియు కేవలం రావచ్చు

665
00:41:03,210 --> 00:41:04,660
దానిని తెరిచి వాటిని చదవండి.

666
00:41:04,660 --> 00:41:07,530
ఆదర్శవంతంగా, అవి ఎన్క్రిప్ట్ అవుతుంది
కొన్ని విధంగా.

667
00:41:07,530 --> 00:41:13,340
మరియు సమస్య 2 లో, మీరు వ్యవహరించే వస్తుంది
ఎన్క్రిప్షన్ యొక్క ఒక పద్దతి తో,

668
00:41:13,340 --> 00:41:16,520
లేదా, బాగా, రెండు పద్ధతులు, కానీ
వారు గొప్ప కాదు.

669
00:41:16,520 --> 00:41:20,050
మీరు హ్యాకర్ ఎడిషన్ చేస్తే, మీరు
కూడా వ్యవహరించే కావడం

670
00:41:20,050 --> 00:41:22,150
కొన్ని విషయాలు మార్చడంలో.

671
00:41:22,150 --> 00:41:29,770
>> కాబట్టి సమస్య ఇప్పుడు, కూడా, ఉంది
మేము శక్తివంతమైన ఎన్క్రిప్షన్ కలిగి

672
00:41:29,770 --> 00:41:34,830
ప్రపంచంలో అల్గోరిథం, మీరు ఒక ఎంచుకోండి
ముఖ్యంగా పేద పాస్వర్డ్ను, అది

673
00:41:34,830 --> 00:41:37,720
, చాలా సహాయపడదు నుండి ప్రజలు
ఇప్పటికీ అది గుర్తించడానికి చేయగలరు.

674
00:41:37,720 --> 00:41:41,530
ఎన్క్రిప్టెడ్ స్ట్రింగ్ చూసిన కూడా
ఇది చెత్త మెస్ కనిపిస్తోంది

675
00:41:41,530 --> 00:41:44,760
ఆ, వాటిని వ్యర్ధము వారు
ఇప్పటికీ కేవలం కొన్ని పాస్వర్డ్లను ప్రయత్నించండి అవసరం

676
00:41:44,760 --> 00:41:50,560
మీరు, అది గుర్తించడానికి
చాలా సురక్షితం కాని.

677
00:41:50,560 --> 00:41:55,890
కాబట్టి ఒక వీడియో చూడటం
ఆ చేస్తుంది.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [వీడియో ప్లేబ్యాక్]

680
00:42:00,970 --> 00:42:02,100
>> -హెల్మెట్, మీరు దయ్యము.

681
00:42:02,100 --> 00:42:03,370
ఏం జరుగుతోంది?

682
00:42:03,370 --> 00:42:05,170
మీరు నా కుమార్తె ఏం చేస్తున్నారు?

683
00:42:05,170 --> 00:42:09,910
>> తెలివైన పరిచయం నన్ను అనుమతి
యువ ప్లాస్టిక్ సర్జన్, డాక్టర్ ఫిలిప్

684
00:42:09,910 --> 00:42:13,730
Schlotkin, గొప్ప ముక్కు
మొత్తం లో ఉద్యోగం మనిషి

685
00:42:13,730 --> 00:42:16,080
విశ్వం మరియు బెవెర్లీ హిల్స్.

686
00:42:16,080 --> 00:42:17,210
>> -ప్యాంటీ.

687
00:42:17,210 --> 00:42:18,070
>> -ముక్కు ఉద్యోగం?

688
00:42:18,070 --> 00:42:18,670
నేను అర్థం లేదు.

689
00:42:18,670 --> 00:42:20,090
ఆమె ఇప్పటికే ముక్కు ఉద్యోగం కనబరచాడు.

690
00:42:20,090 --> 00:42:21,910
ఇది ఒక తీపి పదహారు ఉంది.

691
00:42:21,910 --> 00:42:22,140
>> -సంఖ్య.

692
00:42:22,140 --> 00:42:23,690
మీరు ఏమనుకుంటున్నారో కాదు.

693
00:42:23,690 --> 00:42:25,420
ఇది చాలా చెత్తగా ఉంది.

694
00:42:25,420 --> 00:42:30,300
మీరు నాకు కలయిక ఇవ్వాలని లేదు ఉంటే
గాలి షీల్డ్, డాక్టర్ Schlotkin రెడీ

695
00:42:30,300 --> 00:42:34,226
తన పాత ముక్కు మీ కుమార్తె తిరిగి ఇవ్వాలని.

696
00:42:34,226 --> 00:42:35,476
>> -సంఖ్య.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
మీరు ఎక్కడ ఆ వచ్చింది?

699
00:42:40,516 --> 00:42:41,440
>> -అన్ని కుడి.

700
00:42:41,440 --> 00:42:42,180
నేను చెబుతాడని.

701
00:42:42,180 --> 00:42:43,381
నేను చెబుతాడని.

702
00:42:43,381 --> 00:42:44,263
లేదు, డాడీ.

703
00:42:44,263 --> 00:42:45,590
లేదు, మీరు కాదు తప్పక.

704
00:42:45,590 --> 00:42:46,860
>> -అప్పుడు గుర్తొచ్చింది, నా ప్రియమైన.

705
00:42:46,860 --> 00:42:48,450
నేను మీ కొత్త ముక్కు బాధగా.

706
00:42:48,450 --> 00:42:52,090
ఎట్టిపరిస్థితిలోనూ కలిపి చెప్పదు,
ఎవైనా.

707
00:42:52,090 --> 00:42:53,680
>> -చాలా బాగా.

708
00:42:53,680 --> 00:42:55,685
డాక్టర్ Schlotkin, మీ చెత్త చేయండి.

709
00:42:55,685 --> 00:42:56,914
>> ఏదన్న ఆనందం.

710
00:42:56,914 --> 00:43:00,690
>> [TOOLS పదును కావడంతో]

711
00:43:00,690 --> 00:43:01,910
>> -సంఖ్య.

712
00:43:01,910 --> 00:43:02,520
వేచి.

713
00:43:02,520 --> 00:43:03,836
వేచి.

714
00:43:03,836 --> 00:43:05,300
నేను చెబుతాడని.

715
00:43:05,300 --> 00:43:06,880
నేను చెబుతాడని.

716
00:43:06,880 --> 00:43:09,130
>> -I ఇది పని చేస్తుంది తెలుసు.

717
00:43:09,130 --> 00:43:09,900
అన్ని కుడి.

718
00:43:09,900 --> 00:43:12,850
నాకు ఇచ్చి.

719
00:43:12,850 --> 00:43:16,918
>> -కలయిక ఒకటి.

720
00:43:16,918 --> 00:43:17,406
>> వన్.

721
00:43:17,406 --> 00:43:18,382
>> వన్.

722
00:43:18,382 --> 00:43:19,358
>> టు.

723
00:43:19,358 --> 00:43:19,846
>> టు.

724
00:43:19,846 --> 00:43:20,822
>> టు.

725
00:43:20,822 --> 00:43:21,310
>> మూడు.

726
00:43:21,310 --> 00:43:21,798
>> మూడు.

727
00:43:21,798 --> 00:43:22,774
>> మూడు.

728
00:43:22,774 --> 00:43:23,262
>> ఫోర్.

729
00:43:23,262 --> 00:43:23,750
>> ఫోర్.

730
00:43:23,750 --> 00:43:26,150
>> ఫోర్.

731
00:43:26,150 --> 00:43:27,010
>> -ఐదు.

732
00:43:27,010 --> 00:43:27,670
>> -ఐదు.

733
00:43:27,670 --> 00:43:29,010
>> -ఐదు.

734
00:43:29,010 --> 00:43:34,770
>> -కాబట్టి కలయిక, ఒకటి
రెండు, మూడు, నాలుగు, ఐదు.

735
00:43:34,770 --> 00:43:37,460
ఆ stupidest కలయిక ఉంది
నేను ఎప్పుడూ నా జీవితంలో విన్న.

736
00:43:37,460 --> 00:43:39,710
ఆ విషయం రకం ఒక ఇడియట్ ఉంది
తన లగేజ్ పై.

737
00:43:39,710 --> 00:43:42,000
>> మీ హైనెస్, మీరు ధన్యవాదాలు.

738
00:43:42,000 --> 00:43:43,530
>> -అంటూ?

739
00:43:43,530 --> 00:43:44,490
>> -I గోడ ఆఫ్ చెయ్యబడింది.

740
00:43:44,490 --> 00:43:45,420
>> -మదు చేశాడు.

741
00:43:45,420 --> 00:43:45,840
మీరు మొత్తం సినిమా ఆఫ్ చెయ్యబడింది.

742
00:43:45,840 --> 00:43:46,930
>> -I తప్పు బటన్ ను నొక్కిన ఉండాలి.

743
00:43:46,930 --> 00:43:48,265
>> -సరే, తిరిగి ఉంచండి.

744
00:43:48,265 --> 00:43:49,110
చిత్రం తిరిగి ఉంచండి.

745
00:43:49,110 --> 00:43:49,510
>> -రామరాజు.

746
00:43:49,510 --> 00:43:49,917
రామరాజు.

747
00:43:49,917 --> 00:43:50,324
>> యొక్క, ఆర్నాల్డ్ Go-లెట్.

748
00:43:50,324 --> 00:43:51,140
, గ్రెట్చెన్ కమ్.

749
00:43:51,140 --> 00:43:53,060
వాస్తవానికి, మీరు నేను ఇప్పటికీ చేస్తాము తెలుసు
ఈ కోసం మీరు బిల్లు.

750
00:43:53,060 --> 00:43:53,440
>> [END వీడియో ప్లేబ్యాక్]

751
00:43:53,440 --> 00:43:54,690
>> రాబ్ బోడెన్: అన్ని కుడి.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
మేము ఇప్పటికే గురించి మాట్లాడటం కాబట్టి ఇప్పుడు ఆ
కొన్ని మార్గాల్లో భద్రత, nice

754
00:44:08,430 --> 00:44:16,050
చిన్న చిత్రం పోస్టర్, కాబట్టి ఇటీవల లో
NSA తో రోజుల, ఈ సమస్యలు

755
00:44:16,050 --> 00:44:17,300
ప్రతిదీ పర్యవేక్షణ.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
ఇది మీరు భావిస్తాను కష్టం
గోప్యత విధమైన కలిగి

758
00:44:26,930 --> 00:44:34,540
ఆన్లైన్ ప్రపంచ, నేను చెప్పడం కాదు అయితే
మీరు ప్రిజం యొక్క వివరాలను అత్యంత.

759
00:44:34,540 --> 00:44:42,130
కాబట్టి ప్రిజం దాటి కదిలే, మేము వెళ్ళి లేదు
ఇప్పుడు, గురించి మాట్లాడటం చేయడానికి

760
00:44:42,130 --> 00:44:44,030
మీ ల్యాప్టాప్ గురించి ఆలోచించటం.

761
00:44:44,030 --> 00:44:48,360
కాబట్టి ఇక్కడ, నేను మారాలని అనుకుంటున్నారా
నా అసలు ఖాతాకు,

762
00:44:48,360 --> 00:44:50,370
నా చిన్న పెంగ్విన్ తో.

763
00:44:50,370 --> 00:44:57,310
నేను ఒక పాస్వర్డ్ను సెట్, మరియు ఆ
పాస్వర్డ్ను నేను కావలసినట్లు ఉంది.

764
00:44:57,310 --> 00:45:02,430
>> కానీ గుర్తుంచుకోండి ఏమి నేను కూడాను!
, ఈ లాగిన్ లో

765
00:45:02,430 --> 00:45:04,850
ప్రాంప్ట్, కొన్ని కార్యక్రమం.

766
00:45:04,850 --> 00:45:07,910
ఇది కొంత కార్యక్రమం
కొన్ని వ్యక్తి రాసిన.

767
00:45:07,910 --> 00:45:13,250
కాబట్టి, ఆ వ్యక్తి, ఉంటే వారు
ముఖ్యంగా హానికరమైన, వారు భావించారు

768
00:45:13,250 --> 00:45:17,780
చెప్పారు, అన్ని కుడి, అయితే పాస్వర్డ్ను
నేను ఎంటర్ సమానం నా

769
00:45:17,780 --> 00:45:22,800
వాస్తవ పాస్వర్డ్, లేదా అది సమానంగా
కొన్ని ప్రత్యేక పాస్వర్డ్ -

770
00:45:22,800 --> 00:45:25,550
డేవిడ్ అద్భుతంగా లేదా విషయం -

771
00:45:25,550 --> 00:45:27,190
అప్పుడు వాటిని అనుమతించడానికి

772
00:45:27,190 --> 00:45:33,760
కాబట్టి ఒక హానికరమైన ప్రోగ్రామర్ కలిగి
మీ Macs అన్ని, లేదా యాక్సెస్

773
00:45:33,760 --> 00:45:36,150
Windows, లేదా ఏదైనా.

774
00:45:36,150 --> 00:45:41,980
>> కాబట్టి ఆ, నుండి, గురించి ఎక్కువగా కాదు
నేను అర్థం, ఈ లాగిన్ కార్యక్రమం

775
00:45:41,980 --> 00:45:48,720
ఆ OS X, వందలాది రవాణా యొక్క
లేదా ప్రజలు వేలాది కలిగి

776
00:45:48,720 --> 00:45:50,020
ఈ కోడ్ సమీక్షించారు.

777
00:45:50,020 --> 00:45:55,330
కాబట్టి, మీరు ఎక్కడా మీ కోడ్ లో, ఉంటే
ఈ స్ట్రింగ్ సమానం సమానం చెప్పడానికి

778
00:45:55,330 --> 00:45:58,860
డేవిడ్ అద్భుతం, లాగిన్, అప్పుడు ఒకరి
మాత్రం, వంటి, వేచి.

779
00:45:58,860 --> 00:45:59,800
అంతేకాదు.

780
00:45:59,800 --> 00:46:01,790
ఈ ఇక్కడ కాదు.

781
00:46:01,790 --> 00:46:06,650
కాబట్టి మేము విషయాలు ఒక మార్గం
రకమైన సురక్షితమైనదిగా.

782
00:46:06,650 --> 00:46:10,300
>> కానీ కూడా కార్యక్రమాలు గురించి ఆలోచించటం
మీరు వ్రాసే.

783
00:46:10,300 --> 00:46:13,000
యొక్క లాగిన్ ప్రోగ్రామ్ రాశాడు పిలవబడు.

784
00:46:13,000 --> 00:46:20,440
మీరు రాసిన ఈ లాగిన్ కార్యక్రమం,
కాబట్టి సహజంగా, మీరు ఒక మంచి

785
00:46:20,440 --> 00:46:21,210
ప్రోగ్రామర్.

786
00:46:21,210 --> 00:46:25,610
మీరు ఏ హానికరమైన రాణించాలి చేస్తున్నారు
x సమానం సమానం డేవిడ్ అద్భుతం

787
00:46:25,610 --> 00:46:27,860
మీ కోడ్ లోకి.

788
00:46:27,860 --> 00:46:31,930
కానీ ఈ ప్రోగ్రామ్, మీరు ఏమి
ఈ కార్యక్రమం కంపైల్ ఉపయోగించాలి?

789
00:46:31,930 --> 00:46:34,180
గణగణమని ద్వని చేయు వంటి ఏదో.

790
00:46:34,180 --> 00:46:38,460
కాబట్టి ఏం జరిగింది వ్యక్తి
గణగణమని ద్వని చేయు లో కేస్ గల గణగణమని ద్వని చేయు ప్రత్యేక వ్రాయండి

791
00:46:38,460 --> 00:46:44,310
ఏదో, నేను కంపైల్ am ఉంటే
కార్యక్రమం లాగిన్, అప్పుడు ఈ కోడ్ ఎంటర్

792
00:46:44,310 --> 00:46:49,720
ఉంటే, ఆ లాగిన్ కార్యక్రమంపై
x సమానం డేవిడ్ అద్భుతం సమానం?

793
00:46:49,720 --> 00:46:59,890
కాబట్టి చాలా ఇంకా, కానీ మేము అదే కలిగి
ఇక్కడ జారీ, పేరు గణగణమని ద్వని చేయు, బాగా,

794
00:46:59,890 --> 00:47:03,790
వేలాది లేకపోతే పదుల వేలమంది
ప్రజలు, కలిగి, గణగణమని ద్వని చేయు చూసారా

795
00:47:03,790 --> 00:47:07,160
కోడ్ దాని పంక్తులు చూస్తూ చెప్పారు,
అన్ని కుడి, ఇక్కడ చెడు ఏమీ లేదు.

796
00:47:07,160 --> 00:47:10,680
సహజంగానే, ఎవరూ చేస్తోంది
ఈ హానికరమైన ఏదైనా.

797
00:47:10,680 --> 00:47:15,780
>> కానీ, వంటి, కూడా గణగణమని ద్వని చేయు
నేను గణగణమని ద్వని చేయు కంపైల్ ఉంటే?

798
00:47:15,780 --> 00:47:20,900
నేను కొన్ని కంపైలర్ ఆ
గణగణమని ద్వని చేయు లోకి ఇన్సర్ట్ గణగణమని ద్వని చేయు కూర్చింది

799
00:47:20,900 --> 00:47:25,610
అని ఈ ప్రత్యేక హాక్, అన్ని కుడి,
నేను గణగణమని ద్వని చేయు కంపైల్ సమయంలో, అప్పుడు

800
00:47:25,610 --> 00:47:31,290
executable నేను ప్రత్యేకంగా కనిపించాలి చేసుకోగా
లాగిన్ ప్రోగ్రామ్ మరియు చొప్పించు లోపలి

801
00:47:31,290 --> 00:47:34,230
ఈ పాస్వర్డ్ను, సమానం సమానం
డేవ్ అద్భుతం?

802
00:47:34,230 --> 00:47:37,990
కాబట్టి గుర్తు మీ కంపైలర్ కూడా
ఏదో ఒక సమయంలో సంకలనం అవసరం.

803
00:47:37,990 --> 00:47:42,810
కాబట్టి మీరు గణగణమని ద్వని చేయు కంపైల్ ఎంచుకున్న ఉంటే
, కూడా మీరు, హానికరమైనది తో

804
00:47:42,810 --> 00:47:45,580
మొత్తం వత్తిడి కాలేదు
డౌన్ లైన్.

805
00:47:45,580 --> 00:47:49,630
>> ఇక్కడ, మేము కెన్ థాంప్సన్ కలిగి
మరియు డెన్నిస్ రిట్చీ.

806
00:47:49,630 --> 00:47:53,780
కాబట్టి ఈ గుర్తింపు ఫోటో ఉంది.

807
00:47:53,780 --> 00:47:55,470
డెన్నిస్ రిట్చీ కుడివైపున ఉంది.

808
00:47:55,470 --> 00:47:58,740
అతను ఒక ప్రధాన ఉంది -

809
00:47:58,740 --> 00:48:03,640
చాలా చక్కని C. రాశారు కాబట్టి మీరు
ఈ తరగతి అతనికి ధన్యవాదాలు.

810
00:48:03,640 --> 00:48:04,840
కెన్ థామ్సన్ ఎడమ ఉంది.

811
00:48:04,840 --> 00:48:07,780
వాటిలో ఈరెండు UNIX రాశారు.

812
00:48:07,780 --> 00:48:10,140
బాగా, వారు ప్రధాన చేయలేకపోయారు
UNIX లో.

813
00:48:10,140 --> 00:48:11,310
కొన్ని ఉన్నాయి.

814
00:48:11,310 --> 00:48:16,240
ఏదో ఒక సమయంలో కాబట్టి కెన్ థాంప్సన్,,
అతను ట్యూరింగ్ అవార్డు విజేత.

815
00:48:16,240 --> 00:48:20,860
మరియు ట్యూరింగ్ అవార్డు, నేను ఎల్లప్పుడూ విన్న చేసిన
ఇది ఈ విధంగా సూచించారు, అది

816
00:48:20,860 --> 00:48:23,100
కంప్యూటర్ సైన్స్ నోబెల్ బహుమతి.

817
00:48:23,100 --> 00:48:27,500
>> కాబట్టి ట్యూరింగ్ అవార్డ్, అతను ఉంటుంది
తన ఉపన్యాసంలో ఇవ్వాలని.

818
00:48:27,500 --> 00:48:31,790
మరియు అతను ఈ చాలా ప్రసిద్ధ ప్రసంగం ఇస్తుంది
ఇప్పుడు, నమ్ముతూ ప్రతిఫలనాలు అని

819
00:48:31,790 --> 00:48:35,620
మేము లింక్ ఇది ట్రస్ట్,
కోర్సు వెబ్సైట్లో పొందాలనే.

820
00:48:35,620 --> 00:48:41,670
మరియు ఈ ప్రసంగంలో, అతను, అన్ని కుడి, చెప్పారు
నేను UNIX రాశారు, మరియు ఇప్పుడు అన్ని యొక్క

821
00:48:41,670 --> 00:48:43,320
మీరు ప్రజలు UNIX ఉపయోగిస్తున్నారు.

822
00:48:43,320 --> 00:48:46,960
ఇప్పుడు, Linux అని గుర్తున్నాయి
UNIX యొక్క ప్రత్యక్ష వారసుడు.

823
00:48:46,960 --> 00:48:50,140
OS X నేరుగా UNIX ఉపయోగిస్తుంది.

824
00:48:50,140 --> 00:48:53,810
Windows ఎక్కువ చేస్తుంది, కానీ చాలా
ఆలోచనలు UNIX నుండి తీసిన.

825
00:48:53,810 --> 00:48:59,220
>> కాబట్టి ఆయన దశ వరకు వెళ్లి చెప్పారు
అన్ని కుడి, నేను UNIX రాశారు.

826
00:48:59,220 --> 00:49:03,940
మరియు అందువల్ల మీరు అబ్బాయిలు తెలుసు, నేను ఉన్నాను
ప్రతి లోకి లాగిన్ కాలేరు

827
00:49:03,940 --> 00:49:05,590
మీ కంప్యూటర్ల సింగిల్ను.

828
00:49:05,590 --> 00:49:14,280
X ఉంటే నేను ఈ ప్రత్యేక ఒకటి ఉంచారు నుండి
సమానం, కెన్ థామ్సన్ అద్భుతం సమానం

829
00:49:14,280 --> 00:49:16,350
అప్పుడు నేను లాగిన్ అనుమతి చేస్తున్నాను.

830
00:49:16,350 --> 00:49:18,370
కాబట్టి ప్రజలు, బాగా, వంటి
తెలియక కొంత మీరు అలా?

831
00:49:18,370 --> 00:49:21,090
లాగిన్ కార్యక్రమం చూశారు
మరియు ఏమీ లేదు.

832
00:49:21,090 --> 00:49:24,700
అతను, నేను కంపైలర్ చివరి, వంటిది
లాగిన్ కార్యక్రమంలో లాగిన్

833
00:49:24,700 --> 00:49:30,490
లాగిన్ ఇప్పుడు ఉంటుంది కాబట్టి
ఆ x కెన్ థాంప్సన్ సమానం సమానం

834
00:49:30,490 --> 00:49:31,700
అద్భుతం.

835
00:49:31,700 --> 00:49:33,120
>> మరియు వారు బాగా, నిజమైన కాదు, చెప్పడానికి.

836
00:49:33,120 --> 00:49:35,740
మేము కంపైలర్ చూడటం, మరియు చేస్తున్నారు
కంపైలర్ ఏ లక్షణాలను కలిగి లేదు

837
00:49:35,740 --> 00:49:36,400
వలె కోడ్.

838
00:49:36,400 --> 00:49:40,540
ఆయన OK, వంటిది, కానీ మీరు ఏమి ఉన్నాయి
కంపైలర్ తో కంపైల్?

839
00:49:40,540 --> 00:49:44,810
మరియు, బాగా, వంటి, వారు, మరియు అతను
నేను మీరు కంపైలర్ ఇచ్చిన ఒక ఉన్నాను

840
00:49:44,810 --> 00:49:50,580
మీరు కంపైలర్ కంపైల్ ఉపయోగించి, కాబట్టి చేస్తున్నారు
మీరు, ఒక కంపైలర్ కంపైల్ అని

841
00:49:50,580 --> 00:49:56,390
కూడా హానికరమైనది, మరియు రెడీ
లాగిన్ కార్యక్రమం బ్రేక్.

842
00:49:56,390 --> 00:49:59,360
కాబట్టి ప్రాథమికంగా, ఆ సమయంలో, ఉంది
మీరు సోర్స్ చూడండి అవటానికి మార్గమే

843
00:49:59,360 --> 00:50:02,450
లాగిన్ కార్యక్రమం కోడ్
ఏమి చూడటానికి.

844
00:50:02,450 --> 00:50:04,220
మీరు కూడా లో చూడండి కాదు
కంపైలర్ యొక్క సోర్స్ కోడ్

845
00:50:04,220 --> 00:50:06,790
ఏమి చూడటానికి.

846
00:50:06,790 --> 00:50:11,940
>> మీరు యంత్రం చూడండి అవసరం
కోడ్, వాస్తవ బైనరీ

847
00:50:11,940 --> 00:50:16,760
ఈ, వేచి, చూడటానికి సంకలనం కంపైలర్
లైన్స్ ఆఫ్ కోడ్ ఇక్కడ కాదు.

848
00:50:16,760 --> 00:50:22,130
కానీ కెన్ థాంప్సన్ ఒక మెట్టు
మరింత బాగా, ఉన్నాయి, చెప్పారు

849
00:50:22,130 --> 00:50:25,980
ఈ ప్రత్యేక కార్యక్రమాలు వాస్తవానికి
ప్రోగ్రామ్స్ యొక్క బైనరీ చదవండి సహాయం,

850
00:50:25,980 --> 00:50:29,340
అందువలన ఎవరైనా ఆ ప్రోగ్రాంని ఉంటే
బైనరీ చదవండి, వారు ఈ చూస్తాము

851
00:50:29,340 --> 00:50:30,490
లైన్స్ ఆఫ్ కోడ్.

852
00:50:30,490 --> 00:50:34,020
అతను అన్ని, చెప్పడానికి ఆ కార్యక్రమాలు చివరి
కుడి, మీరు శోధిస్తున్న ఉంటే

853
00:50:34,020 --> 00:50:38,460
కంపైలర్, ఈ ప్రత్యేక చూపవద్దు
బైనరీ సమితి.

854
00:50:38,460 --> 00:50:42,830
>> కాబట్టి మీరు తీసుకోవాలని అవసరమైన ఒక అడుగు
మరింత మరియు ప్రధానంగా, కలిగి

855
00:50:42,830 --> 00:50:46,210
డొంకతిరుగుడు తీసిన బహుళ స్థాయిలు,
మరియు కొన్ని పాయింట్ వద్ద, ఎవరూ నిజానికి

856
00:50:46,210 --> 00:50:47,990
తనిఖీ కావడం.

857
00:50:47,990 --> 00:50:52,590
కాబట్టి కథ యొక్క నైతిక మీరు, ఉంది
రాయడం కావడం లేదు

858
00:50:52,590 --> 00:50:54,340
ఈ తరగతి లో గణగణమని ద్వని చేయు.

859
00:50:54,340 --> 00:50:57,020
మీరు పైకి ఉపయోగించి కావడం
ఈ తరగతి లో చాలా గణగణమని ద్వని చేయు.

860
00:50:57,020 --> 00:51:00,490
మీకు తెలిసిన అన్ని, గణగణమని ద్వని చేయు ఒక హానికరమైనది
ప్రతి sabotaging అని కార్యక్రమం

861
00:51:00,490 --> 00:51:03,520
కార్యక్రమం మీరు సంకలనం చేసిన.

862
00:51:03,520 --> 00:51:08,206
మరియు చాలా అరిష్ట మీరు వదిలి
బుధవారం మీరు చూస్తారు, గమనించండి.

863
00:51:08,206 --> 00:51:10,030
>> [అప్లాజ్]

864
00:51:10,030 --> 00:51:12,935
>> SPEAKER 2: తదుపరి CS50 వద్ద.

865
00:51:12,935 --> 00:51:14,580
>> SPEAKER 3: మీరు అని ధైర్యం లేదు.

866
00:51:14,580 --> 00:51:15,930
మీరు చేయవచ్చు.

867
00:51:15,930 --> 00:51:19,440
మీరు ముందు దీనిని పూర్తి చేసిన, మీరు చేయవచ్చు
నేడు, రేపు చేయవచ్చు.

868
00:51:19,440 --> 00:51:20,930
మీరు సంవత్సరాలు ఈ చేస్తోంది.

869
00:51:20,930 --> 00:51:22,790
కేవలం అక్కడికి వెళ్లి.

870
00:51:22,790 --> 00:51:24,310
మీరు చేయవచ్చు.

871
00:51:24,310 --> 00:51:26,102
>> [MUSIC ప్లే]