1
00:00:08,280 --> 00:00:09,020
[Powered by Google Translate] ZAMYLA చాన్: అన్ని కుడి, ప్రతి ఒక్కరూ.

2
00:00:09,020 --> 00:00:11,130
Walkthrough 1 స్వాగతం.

3
00:00:11,130 --> 00:00:13,950
ఈ Walkthrough C. నేను మీరు ఆశిస్తున్నాము ఉంది pset 1, ఉంటుంది

4
00:00:13,950 --> 00:00:16,540
మీ స్క్రాచ్ ప్రాజెక్టులు ఆనందించండి వచ్చింది.

5
00:00:16,540 --> 00:00:18,430
కాబట్టి ఇప్పుడు ఈ walkthrough లో, మేము నిజంగా మాత్రం చేస్తున్నారు

6
00:00:18,430 --> 00:00:21,580
సి పొందడానికి సామర్థ్యం, ​​కొన్ని యంత్రం కోడ్ రాసేందుకు పొందండి.

7
00:00:21,580 --> 00:00:24,750
మీరు ఈ అప్పుడు, Walkthrough 0 లేదు అలా అయితే

8
00:00:24,750 --> 00:00:26,330
నిజంగా పూర్తి వివరణలు - మేము నడుస్తూ వెళ్లి

9
00:00:26,330 --> 00:00:29,500
సమస్య సెట్, కొన్ని సాధారణ చిట్కాలు మరియు పద్ధతులు ద్వారా చర్చ

10
00:00:29,500 --> 00:00:30,430
మీరు ఉపయోగించే.

11
00:00:30,430 --> 00:00:32,960
మేము ఆ, నిర్వహించడానికి కాటు లోకి అప్పగించిన విచ్ఛిన్నం చేస్తాము

12
00:00:32,960 --> 00:00:35,500
మీరు అబ్బాయిలు ఆశాజనక ప్రారంభించారు మరియు పొందవచ్చు

13
00:00:35,500 --> 00:00:37,470
దీన్ని ఎలా చేయాలో అర్థం.

14
00:00:37,470 --> 00:00:38,050
>> సరే.

15
00:00:38,050 --> 00:00:42,280
Pset 1 కాబట్టి.

16
00:00:42,280 --> 00:00:46,200
ఈ సంవత్సరం మొదటి నిర్మాణం ఉంటుంది psets -

17
00:00:46,200 --> 00:00:48,930
ప్రశ్నలు ఒక విభాగం, వరుస ఉన్నట్లు జరగబోతోంది

18
00:00:48,930 --> 00:00:51,120
నిజంగా కూడా సహాయపడే ప్రశ్నలు మీరు ప్రారంభించడానికి

19
00:00:51,120 --> 00:00:53,840
pset, మీరు అవసరమైన కొన్ని పద్ధతులను పాటిస్తారు సహాయం.

20
00:00:53,840 --> 00:00:55,950
కాబట్టి ఈ ప్రశ్నలు, నేను లో కవర్ చేయడానికి వెళ్ళడం లేదు

21
00:00:55,950 --> 00:00:59,630
walkthrough మీ విభాగంలో, మీ కేటాయించిన టీచింగ్ ఎందుకంటే

22
00:00:59,630 --> 00:01:01,630
తోటి నిజానికి ఆ నడవడానికి అన్నారు

23
00:01:01,630 --> 00:01:02,620
మీరు ప్రశ్నలు.

24
00:01:02,620 --> 00:01:04,370
మీ విభాగాన్ని ముగింపులో, మీరు దూరంగా ఉంటాము

25
00:01:04,370 --> 00:01:07,200
ఆ ప్రశ్నలకు సమాధానాలు కూడా విశ్వాసం తో

26
00:01:07,200 --> 00:01:10,340
మీరు అవసరం కొన్ని ఫీచర్లను అమలు చేయవచ్చు

27
00:01:10,340 --> 00:01:12,480
pset తరువాతి భాగాలు.

28
00:01:12,480 --> 00:01:15,900
>> Pset 1 మారియో ఏర్పరుస్తుంది.

29
00:01:15,900 --> 00:01:19,000
ఆ పేరు తప్పనిసరిగా మేము ఒక ఆహ్లాదకరమైన తక్కువ కార్యక్రమం

30
00:01:19,000 --> 00:01:24,360
వ్రాసి సాధారణ మారియో సన్నివేశంలో సగం పిరమిడ్ ప్రింట్.

31
00:01:24,360 --> 00:01:27,150
ఆపై pset రెండవ భాగం గ్రీడీ అంటారు.

32
00:01:27,150 --> 00:01:29,850
కాబట్టి గ్రీడీ లో మేము ముఖ్యంగా అత్యాశ పని

33
00:01:29,850 --> 00:01:32,780
క్యాషియర్, ఎవరైనా మాకు డబ్బు మొత్తాన్ని ఇస్తాడు ఉంటే

34
00:01:32,780 --> 00:01:38,730
మేము కావలసిన, ఆ నాణేలు కనీస మొత్తం లెక్కించేందుకు

35
00:01:38,730 --> 00:01:40,840
మేము అవి ఆ మొత్తం ఇవ్వాలని వారిని తిరిగి రావచ్చు.

36
00:01:44,080 --> 00:01:44,420
>> అన్ని కుడి.

37
00:01:44,420 --> 00:01:46,970
కాబట్టి ప్రతి walkthrough ఒక పేజీలు ఉంటుంది.

38
00:01:46,970 --> 00:01:50,650
మరియు తిరిగి, మీరు ఈ టూల్స్ లో అన్ని ఉపయోగించదు ఉండవచ్చు

39
00:01:50,650 --> 00:01:53,080
పేజీలు లేదా మీరు వాటిని అన్ని ఉపయోగించవచ్చు.

40
00:01:53,080 --> 00:01:54,550
ఏ సందర్భంలో, తెలుసుకోవాల్సిన మంచి ఏది

41
00:01:54,550 --> 00:01:55,680
మీరు కలిగి ఉన్నాము.

42
00:01:55,680 --> 00:01:59,990
కాబట్టి మేము నేను తెలియజేస్తాము ఇది CS50 ఉపకరణం, మీరు అబ్బాయిలు కలిగి మరియు

43
00:01:59,990 --> 00:02:01,350
ఆ మీరు పరిచయం.

44
00:02:01,350 --> 00:02:05,710
అప్పుడు కూడా సాధారణంగా, మంచి శైలి ఖచ్చితంగా మా ఒకటి

45
00:02:05,710 --> 00:02:07,080
ముఖ్యమైన పనిముట్లు.

46
00:02:07,080 --> 00:02:10,759
శైలి తప్పనిసరిగా మీ కోడ్ ఎలా చదవగలిగే ఉంది సంబంధించిన?

47
00:02:10,759 --> 00:02:12,750
ఎవరో వెళ్లి మీ కోడ్ చదువుతుంది, వారు ఎందుకు చెయ్యాలి

48
00:02:12,750 --> 00:02:13,610
ఒక సులభమైన సమయం?

49
00:02:13,610 --> 00:02:14,630
వారు అర్ధం చేసుకోగలరు?

50
00:02:14,630 --> 00:02:16,610
అది అందమైన ఉంది?

51
00:02:16,610 --> 00:02:21,750
మేము మీ లో చెల్లే వినియోగదారు ఇన్పుట్ ఎలా పొందాలో గురించి మాట్లాడదాము

52
00:02:21,750 --> 00:02:26,430
కార్యక్రమం మారియో రెండు మరియు గ్రీడీ, మీరు చేయాలి ఎందుకంటే

53
00:02:26,430 --> 00:02:31,660
ఇన్పుట్ యూజర్ అడగండి మీరు సంఖ్య రకమైన ఇస్తాయి.

54
00:02:31,660 --> 00:02:35,480
కాబట్టి అప్పుడు మేము నంబర్ చెల్లదు అని నిర్ధారించుకోవాలి.

55
00:02:35,480 --> 00:02:39,010
అప్పుడు స్క్రాచ్ లో గుర్తు, మేము, అటువంటి రిపీట్ వంటి బ్లాక్స్ కలిగి

56
00:02:39,010 --> 00:02:42,300
వరకు రిపీట్, లేదా వేచి ఉండి, లేదా శాశ్వతంగా.

57
00:02:42,300 --> 00:02:45,880
కాబట్టి మేము ఆ C లోకి ఇప్పుడు అనువదించు రకమైన వెళ్లి మీరు

58
00:02:45,880 --> 00:02:49,750
అయితే, అటువంటి కోసం ఉచ్చులు చూడండి, మరియు ఏదైనా-సమయంలో.

59
00:02:49,750 --> 00:02:54,330
అప్పుడు కూడా మేము కూడా న విలువలు తిరిగి ప్రదర్శించడానికి చేయాలి

60
00:02:54,330 --> 00:02:56,500
స్క్రీన్, అది మారియో లేదా గ్రీడీ లో కావచ్చు.

61
00:02:56,500 --> 00:03:01,150
కావున మనం కోసం తీగలను నుండి విషయాలను ప్రింట్ ఎలా మాట్లాడదాము

62
00:03:01,150 --> 00:03:03,070
పూర్ణాంకాల మరియు తేలియాడుతున్న.

63
00:03:03,070 --> 00:03:05,250
మరియు తర్వాత, చివరిగా మనకు ఒక నిజంగా, pseudocode గురించి మాట్లాడదాము

64
00:03:05,250 --> 00:03:07,550
ముఖ్యమైన అంశం ఈ కోర్సు అంతటా గుర్తుంచుకోవడానికి.

65
00:03:07,550 --> 00:03:11,130
నేను కనుగొనేందుకు సమస్య సెట్లతో అత్యంత నాకు సహాయం భావిస్తున్నాను మరియు ఉంటుంది

66
00:03:11,130 --> 00:03:14,260
ఏ C. గురించి ఆలోచిస్తూ ముందు నేను మీరు ఏమి వివరించడానికి

67
00:03:14,260 --> 00:03:15,640
కానీ చర్య వివరిస్తాయి.

68
00:03:15,640 --> 00:03:19,100
కాబట్టి pseudocode రకమైన, ఇంగ్లీష్ మరియు C మధ్య తరహా ఉంది

69
00:03:19,100 --> 00:03:22,980
సరైన సింటాక్స్ లేకుండా ప్రక్రియలు వివరిస్తూ కానీ

70
00:03:22,980 --> 00:03:24,490
ఒక మంచి తగినంత నిర్మాణం అందించడం.

71
00:03:24,490 --> 00:03:27,460
కాబట్టి నేను కూడా మీ కోసం pseudocode కొన్ని ఉదాహరణలు ఉంటుంది

72
00:03:27,460 --> 00:03:28,710
ఈ walkthrough లో.

73
00:03:31,610 --> 00:03:31,940
>> సరే.

74
00:03:31,940 --> 00:03:35,620
కాబట్టి మనం తో కృషి చేస్తాము CS50 పరికరం.

75
00:03:35,620 --> 00:03:38,840
ఇది రకమైన నడిపే ముఖ్యంగా వర్చ్యువల్ మిషన్ యొక్క ఒక

76
00:03:38,840 --> 00:03:40,780
మీ స్వంత కంప్యూటర్ లోపల కంప్యూటర్.

77
00:03:40,780 --> 00:03:42,080
మరియు ఈ ప్రయోజనాలు చాలా ఉన్నాయి.

78
00:03:42,080 --> 00:03:44,780
ఒక మీరు మేము టూల్స్ పలు ఆరంభ అని ఉంది

79
00:03:44,780 --> 00:03:45,980
CS50 కోసం అవసరం.

80
00:03:45,980 --> 00:03:47,940
అలాగే, ఆ ​​ప్రతి ఒక్కరూ, అదే భూమి పై అర్థం

81
00:03:47,940 --> 00:03:50,800
Mac లేదా PC లేదా మరొక ఆపరేటింగ్ సిస్టమ్ అని.

82
00:03:50,800 --> 00:03:53,930
మేము అన్ని వర్చ్యువల్ మిషన్ అమలు చెయ్యవచ్చు.

83
00:03:53,930 --> 00:03:58,800
కాబట్టి manual.cs50.net/appliance వద్ద సూచనలను ఉన్నాయి.

84
00:03:58,800 --> 00:04:02,740
మరియు మీరు ఆ లింక్ కు వెళ్లి సూచనలను అనుసరించండి ఉంటే

85
00:04:02,740 --> 00:04:07,820
అప్పుడు ఆశాజనక మీరు ఉపకరణం ఇన్స్టాల్ చెయ్యవచ్చు.

86
00:04:07,820 --> 00:04:11,390
>> కాబట్టి మొదటి, మీరు ఒక, ఒక అప్లికేషన్ను ఇన్స్టాల్ చేయాలి

87
00:04:11,390 --> 00:04:13,760
వర్చ్యువల్ మిషన్ అమలు చెయ్యడానికి అసలు అప్లికేషన్.

88
00:04:13,760 --> 00:04:15,270
ఆపై మీరు ఉపకరణం డౌన్లోడ్.

89
00:04:15,270 --> 00:04:18,050
కానీ మళ్ళీ, వద్ద సూచనలను ఉన్నాయి

90
00:04:18,050 --> 00:04:21,459
manual.cs50.net/appliance.

91
00:04:21,459 --> 00:04:26,040
నేను ఇప్పటికే నా ఉపకరణం లోడ్ చేసిన, మరియు నేను ఇన్స్టాల్ చేస్తే

92
00:04:26,040 --> 00:04:28,060
VMware Fusion లో.

93
00:04:28,060 --> 00:04:31,250
నేను ఉపకరణం డౌన్లోడ్ ఒకసారి మరియు నేను ఫైలు వెళ్ళాడు.

94
00:04:31,250 --> 00:04:34,690
నేను తెరువు వెళ్లి అప్పుడు దొరకలేదు నేను ఎక్కడ

95
00:04:34,690 --> 00:04:37,550
CS50 ఉపకరణం నిల్వ.

96
00:04:37,550 --> 00:04:39,310
మరియు అక్కడ నుండి, నేను ఇక్కడ నడిచింది.

97
00:04:39,310 --> 00:04:44,520
కానీ నేను ఇప్పటికే ఇక్కడ దానిని కలిగి ఉంటాయి, కాబట్టి యొక్క ఒక సమీప వీక్షణ తీసుకుందాం.

98
00:04:44,520 --> 00:04:44,850
>> అన్ని కుడి.

99
00:04:44,850 --> 00:04:46,770
కాబట్టి ఇప్పుడు మేము CS50 ఉపకరణం లోపల ఉన్నారు.

100
00:04:46,770 --> 00:04:47,890
నేను పూర్తి స్క్రీన్ చేసింది.

101
00:04:47,890 --> 00:04:51,130
మీరు కేవలం అనుకుంటున్నారా లేదా అది ఒక ఉంటాయి చేయడానికి ఎంచుకోవచ్చు

102
00:04:51,130 --> 00:04:53,480
మీ డెస్క్టాప్ మీద చిన్న విండో.

103
00:04:53,480 --> 00:04:57,170
ఇక్కడ మేము తో కేవలం డెస్క్టాప్ కలిగి

104
00:04:57,170 --> 00:04:58,220
ఒక ఇల్లు మరియు ఒక ట్రాష్.

105
00:04:58,220 --> 00:05:05,070
మీరు ప్రోగ్రామింగ్ తరువాత మెనుకు వెళ్లి అయితే, మీరు చూడండి

106
00:05:05,070 --> 00:05:07,570
మేము టెర్మినల్ అనే విషయం.

107
00:05:07,570 --> 00:05:12,340
మరియు ఇక్కడ, మా కంప్యూటర్ చుట్టూ ప్రయాణం చేయవచ్చు.

108
00:05:12,340 --> 00:05:13,360
మేము కోడ్ వ్రాయగలవు.

109
00:05:13,360 --> 00:05:17,240
కానీ నిజానికి, మేము "g gedit అని పిలిచే ఒక కార్యక్రమం ఉపయోగించి, లేదా వస్తుంది

110
00:05:17,240 --> 00:05:20,050
సంకలనం "ఏ ఒక ఉంటుంది.

111
00:05:20,050 --> 00:05:21,680
కాబట్టి మేము ఒక కోడ్ వ్రాయడానికి ఉపయోగించి వస్తారు.

112
00:05:21,680 --> 00:05:24,850
కాబట్టి మీరు ప్రధానంగా ఉపయోగించి మేము ఈ రెండు పరికరాలను కలిగి

113
00:05:24,850 --> 00:05:27,590
కోడ్ రాయడానికి.

114
00:05:27,590 --> 00:05:31,240
అప్పుడు అదనంగా, ఇది ఒక సాధారణ కంప్యూటర్ వంటిది.

115
00:05:31,240 --> 00:05:32,890
మేము ఒక బ్రౌజర్ ఉంది.

116
00:05:32,890 --> 00:05:34,400
మేము Google Chrome ఎంచుకున్నారు.

117
00:05:34,400 --> 00:05:38,720
నేను చేసిన నేను అన్ని కలిగి ఒక డ్రాప్బాక్స్ ఏర్పాటు చేసిన ఉంది

118
00:05:38,720 --> 00:05:39,340
పత్రాలు.

119
00:05:39,340 --> 00:05:41,760
అందువలన, అత్యంత ప్రోత్సహించింది చేసినది ఉంది.

120
00:05:41,760 --> 00:05:44,900
డ్రాప్బాక్స్ మరియు అలా అయితే సమకాలీకరించడాన్ని క్లౌడ్ ఉపయోగిస్తుంది -

121
00:05:44,900 --> 00:05:47,250
కాబట్టి ఉదాహరణకు, అవకాశం ఏదో - కాదు ఆశిస్తున్నాము తెలియజేయండి -

122
00:05:47,250 --> 00:05:50,100
మీ ఉపకరణం ఏమవుతుంది, అది అన్ని ఉంటాం

123
00:05:50,100 --> 00:05:51,350
క్లౌడ్ సమకాలీకరించబడవు.

124
00:05:54,716 --> 00:05:55,180
>> అన్ని కుడి.

125
00:05:55,180 --> 00:05:59,500
కాబట్టి ఆ మీరు ఉపయోగిస్తున్న మేము అనువర్తనాల

126
00:05:59,500 --> 00:06:02,900
CS50 ఉపకరణం.

127
00:06:02,900 --> 00:06:05,750
ఇప్పుడు కమాండ్ లైన్ చుట్టూ నావిగేట్ చెయ్యడానికి.

128
00:06:05,750 --> 00:06:10,150
టెర్మినల్ వాస్తవానికి రకమైన వాస్తవానికి మార్గం పనిచేస్తుంది

129
00:06:10,150 --> 00:06:12,040
లోకి ఆదేశాలను టైప్ -

130
00:06:12,040 --> 00:06:13,650
మీరు ఒక Mac, ఫైండర్ అయితే, ఇష్టం.

131
00:06:13,650 --> 00:06:17,010
మీరు Windows లో అయితే, నేను "నా అన్వేషించడానికి యొక్క నమ్మకం

132
00:06:17,010 --> 00:06:19,070
కంప్యూటర్ "లేదా అలాంటిదే.

133
00:06:19,070 --> 00:06:23,160
మేము ఉపకరణం తిరిగి వెళ్ళడానికి చేస్తే, యొక్క ఒక తెరవడం తెలియజేయండి

134
00:06:23,160 --> 00:06:25,710
టెర్మినల్ విండో.

135
00:06:25,710 --> 00:06:27,720
కాబట్టి ఈ ప్రాంప్ట్, jharvard @ ఉపకరణం ఉంది.

136
00:06:27,720 --> 00:06:32,950
యొక్క ఈ పెద్ద తయారు చేద్దాము.

137
00:06:32,950 --> 00:06:33,790
సరే.

138
00:06:33,790 --> 00:06:40,400
మేము ఆదేశం ls టైప్ కాబట్టి, అప్పుడు జాబితా అన్ని

139
00:06:40,400 --> 00:06:45,440
మా ప్రస్తుత డైరెక్టరీనందు మా కంప్యూటర్ లో ఫైళ్ళను.

140
00:06:45,440 --> 00:06:46,720
డైరెక్టరీలు కేవలం ఫోల్డర్లు వంటివి.

141
00:06:46,720 --> 00:06:49,310
మేము పరస్పరం ఆ పదాలను ఉపయోగిస్తున్నారు.

142
00:06:49,310 --> 00:06:52,480
All right, కాబట్టి మేము ఫైళ్ళను జాబితా చేసిన

143
00:06:52,480 --> 00:06:53,650
ఈ డైరెక్టరీ లో ఉన్నాయి.

144
00:06:53,650 --> 00:06:58,340
ఇప్పుడు మేము ఆక్సెస్ అనుకుంటే, సే, మా డ్రాప్బాక్స్, అప్పుడు మేము

145
00:06:58,340 --> 00:06:59,320
డైరెక్టరీలు మార్చండి.

146
00:06:59,320 --> 00:07:04,230
CD మరియు తరువాత డ్రాప్బాక్స్ కాబట్టి.

147
00:07:04,230 --> 00:07:10,860
మేము ls మళ్ళీ, ఆపై మేము లో ఫైళ్ళను జాబితా చూడండి

148
00:07:10,860 --> 00:07:11,790
ఈ ఫోల్డరును.

149
00:07:11,790 --> 00:07:15,590
ఈ చేసి, నా ఇంటికి వెళ్ళి సమానంగా ఉంటుంది

150
00:07:15,590 --> 00:07:19,250
డ్రాప్బాక్స్, మరియు ఇక్కడ జాబితా చూసిన.

151
00:07:19,250 --> 00:07:20,090
>> అన్ని కుడి.

152
00:07:20,090 --> 00:07:22,220
కాబట్టి అనుకుందాము -

153
00:07:22,220 --> 00:07:25,640
మీరు అబ్బాయిలు మీ pset 1 సిధ్ధంగా చేసినప్పుడు, లెట్స్ ఒక తయారు

154
00:07:25,640 --> 00:07:27,390
డైరెక్టరీ pset1 అని.

155
00:07:27,390 --> 00:07:32,170
మీరు ఈ నుండి చూడగలరు కాబట్టి మేము ఇప్పుడు డ్రాప్బాక్స్ లో ఉన్నాము

156
00:07:32,170 --> 00:07:32,700
ఇక్కడ క్లిక్ చెయ్యండి.

157
00:07:32,700 --> 00:07:34,320
కాబట్టి యొక్క డైరెక్టరీ తయారు చేద్దాము.

158
00:07:34,320 --> 00:07:37,940
Mkdir కాబట్టి, ఇది pset1 కాల్ తెలియజేయండి.

159
00:07:40,470 --> 00:07:43,500
కాబట్టి ఇప్పుడు మేము ls మళ్లీ, అప్పుడు మేము

160
00:07:43,500 --> 00:07:45,390
pset1 కనిపించే చూడండి.

161
00:07:45,390 --> 00:07:49,470
మేము pset1 లోపల వెళ్లాలనుకుంటే కాబట్టి, అప్పుడు మేము లోపల వెళ్ళే

162
00:07:49,470 --> 00:07:54,230
ఆదేశం CD ఆ ఫోల్డర్.

163
00:07:54,230 --> 00:07:54,610
అన్ని కుడి.

164
00:07:54,610 --> 00:07:59,040
మరలా, మేము యొక్క చూసేలా -

165
00:07:59,040 --> 00:08:01,620
సే, అది మరొక విధంగా చేయండి చూద్దాం.

166
00:08:01,620 --> 00:08:03,550
ఇది "సృష్టించు చెప్పడం సమానంగా ఉంటుంది

167
00:08:03,550 --> 00:08:05,330
ఒక క్రొత్త ఫోల్డర్, pset1.

168
00:08:05,330 --> 00:08:08,530
మీరు కనుగొనడానికి కానీ, మీరు పరిచయాత్మకంగా వస్తుంది

169
00:08:08,530 --> 00:08:09,310
టెర్మినల్ చాలా.

170
00:08:09,310 --> 00:08:11,900
కాబట్టి కొన్నిసార్లు చాలా సులభం, ఒక వేగంగా కోల్పోయింది కేవలం

171
00:08:11,900 --> 00:08:15,900
విషయాలు ఇలాంటి విధమైన చేయడానికి టెర్మినల్ పని.

172
00:08:15,900 --> 00:08:16,140
సరే.

173
00:08:16,140 --> 00:08:18,150
మరియు ఈ ఇతర ఆదేశాలను.

174
00:08:18,150 --> 00:08:20,410
ఒక ఫైల్ను తొలగించండి కోసం ఒక RM ఉంది.

175
00:08:20,410 --> 00:08:22,690
కాబట్టి మీరు కేవలం యొక్క పేరు తర్వాత RM టైప్ మరియు

176
00:08:22,690 --> 00:08:23,800
దానిని తొలగించండి దాఖలు.

177
00:08:23,800 --> 00:08:25,810
మేము ఆ తరువాత కొన్ని ఉదాహరణలు లోకి తీసుకెళ్తుంది.

178
00:08:25,810 --> 00:08:28,840
మరియు తర్వాత ఆ వ్యక్తి ఆదేశం అనే కలిగి

179
00:08:28,840 --> 00:08:31,850
విధి యొక్క రకం కోసం మానవీయ వస్తుంది.

180
00:08:31,850 --> 00:08:34,419
మళ్ళీ, నేను తర్వాత ఆ యొక్క ఒక వాస్తవ ఉదాహరణ తీసుకురావటానికి చేస్తాము.

181
00:08:37,360 --> 00:08:39,900
>> మరొక నిజంగా ముఖ్యమైన సాధనం కాబట్టి, నేను కొంతకాలం పేర్కొన్న

182
00:08:39,900 --> 00:08:41,280
ముందు, శైలి.

183
00:08:41,280 --> 00:08:43,650
కాబట్టి ముఖ్యంగా, శైలి చదవడానికి సంబంధం కలిగి ఉంటుంది.

184
00:08:43,650 --> 00:08:46,460
ఎవరో, చదవడానికి అనుసరించండి చేయగలరు, మరియు విల్

185
00:08:46,460 --> 00:08:47,670
మీ కోడ్ అర్థం?

186
00:08:47,670 --> 00:08:50,490
ఈ నిజానికి, మీరు, మీ కోసం ప్రత్యేకంగా ముఖ్యమైనది.

187
00:08:50,490 --> 00:08:53,060
మీరు మీరు తర్వాత చివరి కోడింగ్ అప్ ఉండిపోయారు మరియు మీరు

188
00:08:53,060 --> 00:08:55,940
ఈ వేరియబుల్ ఏమి అర్ధం, తిరిగి వెళ్ళి, మీకు లాగ ఉన్నాము?

189
00:08:55,940 --> 00:08:58,400
సే, మీరు ఒకరితో సమూహం ప్రాజెక్ట్ పని, మరియు మీరు

190
00:08:58,400 --> 00:09:00,130
రెండు ఒకరి కోడ్ దృష్టి ఉంటుంది.

191
00:09:00,130 --> 00:09:03,380
మీరు సరిగ్గా మీ వేరియబుల్స్ పేరు నిజంగా ముఖ్యం

192
00:09:03,380 --> 00:09:06,240
మరియు అన్ని వ్యత్యాసం చేస్తుంది ఎందుకంటే అది మంచి చెయ్యి.

193
00:09:06,240 --> 00:09:08,270
కానీ అన్ని పైన, మేము ప్రస్తుతం ఒక కోర్సులో ఉంటాయి.

194
00:09:08,270 --> 00:09:10,660
కాబట్టి CS50 యొక్క ఆసక్తి మరియు ముఖ్యంగా మీ కోసం

195
00:09:10,660 --> 00:09:13,010
మీ చూడటం చేసే టీచింగ్ సభ్యులు మరియు graders

196
00:09:13,010 --> 00:09:15,455
psets, దయచేసి సరైన శైలి ఉపయోగించండి.

197
00:09:15,455 --> 00:09:18,980
మరియు మీ బోధన సభ్యులు చాలా ఆనందంగా ఉంటుంది.

198
00:09:18,980 --> 00:09:22,890
మరలా, శైలి, సరిగ్గా విషయాలు ఇండెంటింగ్ చెయ్యడం కూడా ఉంటుంది

199
00:09:22,890 --> 00:09:26,380
ముఖ్యంగా మీ బంధాలను ఉపయోగించి మరియు ఆ ఇండెంటింగ్ చెయ్యడం.

200
00:09:26,380 --> 00:09:29,910
వేరియబుల్స్ అర్ధమే ఏదో నామకరణ.

201
00:09:29,910 --> 00:09:32,330
మీరు ఉన్నప్పుడు ప్రస్తుతం మేము సమావేశం అనుసరించండి

202
00:09:32,330 --> 00:09:35,240
మీ వేరియబుల్ పేరు బహుళ పదాలు, అప్పుడు మీరు

203
00:09:35,240 --> 00:09:37,480
మీరు ఆ చూసే వంటి, ఒక తక్కువగా వాటిని కనెక్ట్

204
00:09:37,480 --> 00:09:39,660
ఉదాహరణకు పేరు.

205
00:09:39,660 --> 00:09:41,740
>> అప్పుడు చివరకు, ఏదో మ్యాజిక్ సంఖ్యలు అని.

206
00:09:41,740 --> 00:09:48,030
ముఖ్యంగా, మీరు కోడ్ ద్వారా చదవడం మరియు చెప్పడానికి చేసినప్పుడు

207
00:09:48,030 --> 00:09:51,570
మీరు ఒక వేరియబుల్ కలిగి -

208
00:09:51,570 --> 00:09:56,680
సే, మీరు ఒక వేరియబుల్ కానీ కేవలం సరే చెప్పలేను, వరకు అటువంటి

209
00:09:56,680 --> 00:09:58,600
మరియు తక్కువ కంటే 10 ఉంది.

210
00:09:58,600 --> 00:10:00,210
అప్పుడు మీ grader, వేచి, అనుకూలిస్తే అన్నారు

211
00:10:00,210 --> 00:10:01,320
ఆ 10 పేరు నుండి వచ్చింది?

212
00:10:01,320 --> 00:10:05,040
కాబట్టి ఖచ్చితంగా చాలా మేటర్స్ వివరిస్తుంది.

213
00:10:05,040 --> 00:10:06,740
మీరే వివరించటంలో సహాయపడుతుంది వ్యాఖ్యలు ఉంది.

214
00:10:06,740 --> 00:10:09,850
వ్యాఖ్యలు బహుశా చేర్చడం అత్యంత ముఖ్యమైన విషయం ఉంటాయి

215
00:10:09,850 --> 00:10:11,460
మీ కార్యక్రమాలు.

216
00:10:11,460 --> 00:10:15,440
మరియు మీరు మాత్రమే వాస్తవానికి వివరించలేదు సహాయపడుతుంది -

217
00:10:15,440 --> 00:10:17,220
మీరు రకమైన మీ కారణాన్ని వివరిస్తుంది సహాయం

218
00:10:17,220 --> 00:10:17,870
మీరు వెంట వెళుతున్న.

219
00:10:17,870 --> 00:10:20,480
మీరు ఇలా చేస్తే కాబట్టి, మళ్ళీ, అది చాలా సులభం చేస్తాడు

220
00:10:20,480 --> 00:10:23,370
మీ కోడ్ మరియు రకమైన లో తిరిగి వెళ్ళడానికి మీరు ఏమి చేస్తున్నామో అర్థం

221
00:10:23,370 --> 00:10:24,080
అక్కడ చేయడం.

222
00:10:24,080 --> 00:10:26,410
మళ్లీ, graders వ్యాఖ్యలు నిజంగా ఇష్టం.

223
00:10:26,410 --> 00:10:28,940
కాబట్టి మీరు కూడా మీరే మరియు -

224
00:10:28,940 --> 00:10:29,970
ఉచిత పాయింట్ల రకం.

225
00:10:29,970 --> 00:10:32,340
మరియు ఉచిత పాయింట్ల లేదు?

226
00:10:32,340 --> 00:10:33,910
మీరు బహుళ లైన్ వ్యాఖ్యలు ఉన్నాయి.

227
00:10:33,910 --> 00:10:36,630
కాబట్టి నేను ఇక్కడ టెంప్లేట్ అప్ ఒక రకమైన ఉన్నాయి.

228
00:10:36,630 --> 00:10:38,580
ముఖ్యంగా, సాధారణంగా ఈ మీ ఎగువన ఉపయోగిస్తారు

229
00:10:38,580 --> 00:10:40,950
రకం ప్రోగ్రామ్ సాధారణంగా వివరించడానికి ఏ

230
00:10:40,950 --> 00:10:43,220
మీ సమస్య సెట్ చేస్తుంది.

231
00:10:43,220 --> 00:10:46,130
మీ పేరు, తేదీ, et సెటేరా చేర్చండి.

232
00:10:46,130 --> 00:10:49,030
కాబట్టి, నేను ఈ బహుళ పంక్తి వ్యాఖ్య అన్నట్లు,

233
00:10:49,030 --> 00:10:56,260
manual.cs50.net/style_guide గురించి మరిన్ని చిట్కాల మరియు నిబంధనలు ఉన్నాయి

234
00:10:56,260 --> 00:10:59,310
ఉచ్చులు, et సెటేరా కోసం శైలి.

235
00:10:59,310 --> 00:10:59,740
>> సరే.

236
00:10:59,740 --> 00:11:03,600
కాబట్టి ఇప్పుడు నేను శైలి గురించి మీరు కొంచెం చెప్పారు చేసారు, యొక్క చూసేలా

237
00:11:03,600 --> 00:11:07,390
ఈ యాక్షన్.

238
00:11:07,390 --> 00:11:07,770
అన్ని కుడి.

239
00:11:07,770 --> 00:11:11,850
ఇక్కడ, టామీ మాకు ఒక ఉల్లాసకరమైన భయంకరమైన వ్రాశారు

240
00:11:11,850 --> 00:11:15,440
ఒక కార్యక్రమంలో శైలి యొక్క ఉదాహరణ.

241
00:11:15,440 --> 00:11:17,170
కాబట్టి మీరు ఇక్కడ అన్ని కుడి చూడండి.

242
00:11:17,170 --> 00:11:18,280
ఈ నిజానికి హక్కు.

243
00:11:18,280 --> 00:11:22,060
మీరు ఇక్కడ బహుళ పంక్తి వ్యాఖ్య చూడండి.

244
00:11:22,060 --> 00:11:25,120
మీరు ముందుకు స్లాష్ మరియు తరువాత రెండు ఆస్టరిస్క్లు తో ప్రారంభించండి.

245
00:11:25,120 --> 00:11:28,580
మీరు రేఖ వెంట ఆస్టరిస్క్లు అమర్చడానికి, వెంట కొనసాగుతుంది

246
00:11:28,580 --> 00:11:30,540
మరియు తర్వాత ఒక యాస్ట్రిక్ మరియు స్లాష్ తో ముగుస్తుంది.

247
00:11:30,540 --> 00:11:30,810
అన్ని కుడి.

248
00:11:30,810 --> 00:11:32,800
కాబట్టి ఆ మంచిది.

249
00:11:32,800 --> 00:11:33,760
ఈ ఇక్కడ మంచిది.

250
00:11:33,760 --> 00:11:35,110
తన గ్రంథాలయాలు ఉన్నాయి అన్నారు.

251
00:11:35,110 --> 00:11:38,790
కానీ ఇక్కడ అతను బహుళ పంక్తుల విస్తరించి వ్యాఖ్యలు ఉన్నాయి.

252
00:11:38,790 --> 00:11:40,390
ఈ తప్పు విషయాలు చాలా ఉన్నాయి.

253
00:11:40,390 --> 00:11:44,770
బహుళ పంక్తుల విస్తరించి వ్యాఖ్యలు ఇక్కడే అతను ఉపయోగించి యొక్క

254
00:11:44,770 --> 00:11:47,230
కేవలం ఒక్క లైన్ కామెంట్స్ కొరకు సింటాక్స్.

255
00:11:47,230 --> 00:11:53,140
అతను అదే వ్యాఖ్య లోకి ప్రతిదీ మిశ్రమం యొక్క.

256
00:11:53,140 --> 00:11:54,715
కాబట్టి మేము ఆ నివారించడానికి కావలసిన.

257
00:11:57,710 --> 00:12:03,010
ఇక్కడ మేము ఈ జంట కలుపులు, ఉదాహరణకు, అన్ని అని చూడండి

258
00:12:03,010 --> 00:12:03,730
ప్రాంతం పై.

259
00:12:03,730 --> 00:12:06,950
ఇండెంటేషన్ని తప్పు.

260
00:12:06,950 --> 00:12:09,460
ఇది నిజంగా కచ్చితంగా పేరు ఏదో మీరు లేదు

261
00:12:09,460 --> 00:12:12,850
ప్రారంభాల్లో మరియు మరొక విషయం ముగుస్తుంది.

262
00:12:12,850 --> 00:12:16,510
అప్పుడు కూడా, మేము ఆయన ఇక్కడ నిర్దిష్ట వేరియబుల్ i = 5 ఉన్నాయో చూడండి.

263
00:12:16,510 --> 00:12:18,620
కానీ ఈ నాలుగు నోవేర్ బయటకు వచ్చింది, మరియు లేదు

264
00:12:18,620 --> 00:12:21,520
నుండి వస్తుంది నిజంగా వివరించడానికి మీరే.

265
00:12:21,520 --> 00:12:22,130
>> సరే.

266
00:12:22,130 --> 00:12:28,760
కాబట్టి ఇప్పుడు యొక్క నిజానికి అదే అని ఏదో చూద్దాం

267
00:12:28,760 --> 00:12:30,250
మంచి శైలి తప్ప కోడ్.

268
00:12:30,250 --> 00:12:32,485
మరలా, ఈ, మంచి శైలి ఉదాహరణ

269
00:12:32,485 --> 00:12:33,735
బహుళ లైన్ ఉదాహరణ.

270
00:12:38,400 --> 00:12:39,735
మరియు ఇక్కడ చాలా శుభ్రంగా ఉంది.

271
00:12:39,735 --> 00:12:43,500
మేము ఆయన ఇక్కడ ఒక ప్రకటన ఉంటే ప్రారంభమయ్యే చూడండి, ఒక కొత్త ప్రవేశిస్తుంది

272
00:12:43,500 --> 00:12:46,400
లైన్, ఒక ఓపెన్ కలుపు ఉంది.

273
00:12:46,400 --> 00:12:48,740
ఆ తరువాత ఆయన ఒక ఇండెంటేషన్ని ఉంది.

274
00:12:48,740 --> 00:12:50,970
అతను ఈ ఇండెంటేషన్ని ఉంచుతుంది -

275
00:12:50,970 --> 00:12:54,680
అతను మొత్తంలో ఈ సూచన ఏకరీతి ఉంచుతుంది

276
00:12:54,680 --> 00:12:59,120
కార్యక్రమం మరియు కోడ్ ఒకటి బ్లాక్ బయలుదేరినప్పుడు నిజంగా చూపిస్తుంది, ఎప్పుడు

277
00:12:59,120 --> 00:13:00,780
కోడ్ యొక్క ఒక బ్లాక్ ముగుస్తుంది.

278
00:13:00,780 --> 00:13:04,410
ఈ ప్రారంభించడానికి మా చిన్న nitpicky విధంగా

279
00:13:04,410 --> 00:13:06,370
తో, కానీ మీరు మీ కోడ్ రాస్తున్నాం వంటి మీరు చూస్తారు.

280
00:13:06,370 --> 00:13:09,400
ఈ వేరు చెయ్యడానికి నిజంగా ఉపయోగం.

281
00:13:09,400 --> 00:13:12,200
మరోసారి, మీ graders ఆ నిజంగా ఇష్టం.

282
00:13:12,200 --> 00:13:14,360
కాబట్టి మీరు బదులుగా కేవలం ఒక సంఖ్య ఉంచడం యొక్క, చూడండి

283
00:13:14,360 --> 00:13:17,510
అక్కడ, అతను వాస్తవానికి వేరియబుల్ నిద్రావస్థ అనే.

284
00:13:17,510 --> 00:13:20,160
కాబట్టి మేము నిజానికి ప్రస్తుతం ఈ కోడ్ చూడటం లేదు

285
00:13:20,160 --> 00:13:22,450
కానీ ఒక ఉదాహరణ చూసిన చూస్తూ ఉంటాము

286
00:13:22,450 --> 00:13:23,780
మంచి చెడు వర్సెస్ శైలి.

287
00:13:23,780 --> 00:13:29,610
మీరు వాటిని ఇక్కడ వద్ద పక్కపక్కనే చూస్తే కాబట్టి, మీరు ఆ

288
00:13:29,610 --> 00:13:32,910
ఖచ్చితంగా కుడివైపు ఒక చదవడానికి ఇష్టపడతారు.

289
00:13:39,230 --> 00:13:40,100
>> అన్ని కుడి.

290
00:13:40,100 --> 00:13:42,710
కాబట్టి ఒక లాస్ట్ థింగ్ మేము యొక్క నిజమైన మాంసం ప్రవేశిస్తాడు ముందు

291
00:13:42,710 --> 00:13:46,260
pset మీ కోడ్ కంపైల్ మరియు అమలు ఎలా ఉంది.

292
00:13:46,260 --> 00:13:50,320
కాబట్టి ముఖ్యంగా మీరు నిజంగా కాదు ఆ C, వ్రాస్తున్నప్పుడు

293
00:13:50,320 --> 00:13:52,480
రియల్ యంత్రం కోడ్, మరియు సున్నాల అనువదించబడింది

294
00:13:52,480 --> 00:13:56,000
యంత్రం చదివి అర్థం చేసుకోవచ్చు వాటిని.

295
00:13:56,000 --> 00:13:57,170
కాబట్టి మేము ఏదైనా కలిగి -

296
00:13:57,170 --> 00:13:59,340
గణగణమని ద్వని చేయు మేము C. ఉపయోగించడానికి ఒక కంపైలర్ ఉంది

297
00:13:59,340 --> 00:14:00,270
అనేక కంపైలర్సును ఉన్నాయి.

298
00:14:00,270 --> 00:14:02,480
కానీ CS50 లో, మేము గణగణమని ద్వని చేయు ఉపయోగించి వస్తారు.

299
00:14:02,480 --> 00:14:05,480
కాబట్టి గణగణమని ద్వని చేయు ప్రధానంగా సి నుండి యంత్రం అనువాదం

300
00:14:05,480 --> 00:14:07,380
మీరు కోసం కోడ్.

301
00:14:07,380 --> 00:14:10,170
డైవ్ ఉపకరణం వలె ఇక్కడ - కాబట్టి యొక్క ఒక ఉదాహరణ చూద్దాం.

302
00:14:14,550 --> 00:14:15,030
అన్ని కుడి.

303
00:14:15,030 --> 00:14:16,670
కాబట్టి ఇప్పుడు మేము మా హోమ్ డైరెక్టరీలో ఉన్నారు.

304
00:14:16,670 --> 00:14:18,680
ఏ కోడ్ ఉన్న మేము నిజంగా కాదు.

305
00:14:18,680 --> 00:14:24,740
కాబట్టి, ఇక్కడ యొక్క Dropbox/walkthrough1 మా డైరెక్టరీ మార్చుకోవడానికి అనుమతించే

306
00:14:24,740 --> 00:14:25,930
నేను కొన్ని కోడ్ నిల్వ చేసిన.

307
00:14:25,930 --> 00:14:29,340
మేము ls నొక్కండి చేస్తే, అప్పుడు మేము నేను కలిగి చూడండి ఒక

308
00:14:29,340 --> 00:14:31,230
ఇక్కడ ఫైళ్ళను జంట.

309
00:14:31,230 --> 00:14:31,700
>> అన్ని కుడి.

310
00:14:31,700 --> 00:14:35,280
నేను ఇప్పటికే hello.c వ్రాయలేదు, కాబట్టి ఇది కంపైల్ తెలియజేయండి

311
00:14:35,280 --> 00:14:36,670
మరియు తర్వాత అది చూడటానికి.

312
00:14:36,670 --> 00:14:43,150
కాబట్టి ఒక ప్రాథమిక కంపైల్ ఆదేశం, అప్పుడు hello.c గణగణమని ద్వని చేయు ఉంటుంది

313
00:14:43,150 --> 00:14:46,910
ముఖ్యంగా సరే చెప్పడం, నాకు hello.c కంపైల్.

314
00:14:46,910 --> 00:14:50,550
నేను Enter ని క్లిక్ చెయ్యండి, కుడి పోయింది తెలుస్తోంది.

315
00:14:50,550 --> 00:14:52,590
యొక్క మళ్లీ ls క్లిక్ చేయండి.

316
00:14:52,590 --> 00:14:55,230
ఈ a.out ఫైల్ ఇప్పుడు చూపించింది.

317
00:14:55,230 --> 00:14:57,430
కాబట్టి a.out ఒక ఎక్జిక్యూటబుల్ ఫైల్.

318
00:14:57,430 --> 00:15:05,330
కనుక ఇది అమలు చేయడానికి, మీరు ఒక. / A.out చేయండి.

319
00:15:05,330 --> 00:15:07,650
కాబట్టి మేము స్పష్టంగా ఈ hello.c కార్యక్రమం చూడండి

320
00:15:07,650 --> 00:15:10,400
హలో ఐదుసార్లు ముద్రిస్తుంది.

321
00:15:10,400 --> 00:15:10,990
అన్ని కుడి.

322
00:15:10,990 --> 00:15:14,250
కానీ మేము పేరు a.out ఉపయోగించడానికి మీరు చెప్పే.

323
00:15:18,140 --> 00:15:21,080
ఉదాహరణకు, మేము హలో ప్రోగ్రామ్ను అమలు చేయడానికి కావలసిన ఎందుకంటే

324
00:15:21,080 --> 00:15:22,540
సులభంగా అర్థం చేస్తుంది.

325
00:15:22,540 --> 00:15:26,590
కాబట్టి ముఖ్యంగా మీరు అవసరం తర్వాత యొక్క గణగణమని ద్వని చేయు hello.c అని పిలవబడు, మరియు

326
00:15:26,590 --> 00:15:29,030
జెండాలు అని కొన్ని విషయాలు లో పాస్.

327
00:15:29,030 --> 00:15:31,600
కాబట్టి ఓకే చెప్పాడు, అలాగే నేను ఇంకా ఈ ఏదో పేరు పెట్టాలనుకున్న.

328
00:15:31,600 --> 00:15:33,900
మీరు కూడా, వివిధ జెండాలు చాలా లో తరలిస్తారు

329
00:15:33,900 --> 00:15:34,620
మీరు చూస్తారు.

330
00:15:34,620 --> 00:15:37,510
కాబట్టి ఒక కార్యక్రమం ఏదో పేరు కోసం ఫ్లాగ్ మీరు

331
00:15:37,510 --> 00:15:39,780
IS-o కావలసిన.

332
00:15:39,780 --> 00:15:42,470
-O తరువాత, మీరు ప్రోగ్రామ్ యొక్క పేరు వ్రాయండి.

333
00:15:42,470 --> 00:15:44,090
యొక్క కేవలం హలో కాల్ లెట్.

334
00:15:44,090 --> 00:15:49,050
>> కాబట్టి ఇప్పుడు మనం అసలైన హలో ఎక్జిక్యూటబుల్ ఫైల్ కలిగి చూడండి.

335
00:15:49,050 --> 00:15:54,020
కాబట్టి మేము దీన్ని అమలు చేయవచ్చు, మరియు అది ముందు అదే విషయం చేస్తుంది.

336
00:15:54,020 --> 00:15:56,210
కాబట్టి ఇప్పుడు మేము హలో కలిగి, మేము కూడా కోసం, తొలగించవచ్చు

337
00:15:56,210 --> 00:15:57,450
ఉదాహరణకు, మా a.out.

338
00:15:57,450 --> 00:16:03,880
తీసివేయి, a.out కోసం కాబట్టి RM, మీ టెర్మినల్ మీరు, అడగండి అడుగుతుంది

339
00:16:03,880 --> 00:16:05,470
మీరు నిజంగా లేదో నిర్ధారించడానికి కోసం

340
00:16:05,470 --> 00:16:06,370
తొలగించండి లేదా.

341
00:16:06,370 --> 00:16:10,000
మేము అవును కోసం Y చెప్పారు.

342
00:16:10,000 --> 00:16:10,750
మరియు అక్కడ మేము వెళ్ళి.

343
00:16:10,750 --> 00:16:12,220
A.out వెళ్లిపోయిన.

344
00:16:12,220 --> 00:16:12,620
అన్ని కుడి.

345
00:16:12,620 --> 00:16:14,810
కానీ కొన్నిసార్లు అది గుర్తు అయోమయాన్ని అవుతుంది

346
00:16:14,810 --> 00:16:17,160
మేము ఉన్నాయి మరియు గణగణమని ద్వని చేయు అవుట్ టైప్ అవసరమైన జెండాలు.

347
00:16:17,160 --> 00:16:20,410
మేము మరింత క్లిష్టమైన ప్రోగ్రామ్ల చేసినప్పుడు మేము చూడండి గా మరియు, మేము చేస్తాము

348
00:16:20,410 --> 00:16:22,450
వివిధ గ్రంథాలయాలు కలిగి ఉండే.

349
00:16:22,450 --> 00:16:27,230
కాబట్టి గణగణమని ద్వని చేయు మా ఆదేశాలను ఇక మరియు ఎక్కువ పొందుతారు.

350
00:16:27,230 --> 00:16:30,660
చేస్తుంది ఆదేశాలు CS50 ఉపకరణం చేర్చారు.

351
00:16:30,660 --> 00:16:33,880
కాబట్టి మీరు కేవలం హలో తయారు టైప్ చేయండి.

352
00:16:33,880 --> 00:16:35,130
అయ్యో.

353
00:16:36,860 --> 00:16:38,400
మేము ఇప్పటికే ఈ ఎక్జిక్యూటబుల్ ఫైల్ చేసిన.

354
00:16:38,400 --> 00:16:39,650
కాబట్టి నాకు కేవలం త్వరగా తొలగించడానికి.

355
00:16:42,260 --> 00:16:44,830
ఇప్పుడు హలో తయారు యొక్క టైప్ తెలియజేయండి.

356
00:16:44,830 --> 00:16:49,470
మరియు మీరు తప్పనిసరిగా చెప్పడం చేసే ఇక్కడ ఈ లైన్ లో చూడండి

357
00:16:49,470 --> 00:16:54,760
హలో ఈ ఆదేశాలను అన్ని కూడుకుని

358
00:16:54,760 --> 00:16:55,580
మీ కోసం వెళ్తాయి.

359
00:16:55,580 --> 00:16:58,080
>> చేస్తుంది ఫైలు CS50 ఉపకరణం చేర్చారు.

360
00:16:58,080 --> 00:17:02,300
కాబట్టి మీరు ఒక ఫైల్ name.c కలిగి కేవలం ఉన్నప్పుడు, అప్పుడు అన్ని మీరు

361
00:17:02,300 --> 00:17:03,680
ఫైల్ పేరు తయారు చెప్పాలి.

362
00:17:03,680 --> 00:17:04,800
ఆపై మీరు ఒక ఎక్జిక్యూటబుల్ ఉంటుంది

363
00:17:04,800 --> 00:17:06,200
ఆ పేరుతో ఫైల్.

364
00:17:06,200 --> 00:17:06,675
అవును?

365
00:17:06,675 --> 00:17:09,525
>> SPEAKER 1: బదులుగా గణగణమని ద్వని చేయు నా కంప్యూటర్, దీనిని GCC చెప్పారు.

366
00:17:09,525 --> 00:17:11,910
ఆ లాగా ఉంటుంది -

367
00:17:11,910 --> 00:17:12,109
ZAMYLA చాన్: అవును.

368
00:17:12,109 --> 00:17:15,700
మీ కంప్యూటర్ కు గణగణమని ద్వని చేయు GCC వంటి వ్యతిరేకంగా అనవచ్చు ఎందుకంటే

369
00:17:15,700 --> 00:17:18,180
GCC కంపైలర్ యొక్క మరొక రకం.

370
00:17:18,180 --> 00:17:20,460
మీరు అయితే CS50 ఉపకరణం ఉన్నట్లయితే, అప్పుడు

371
00:17:20,460 --> 00:17:21,810
గణగణమని ద్వని చేయు ఉపయోగించి ఉండాలి.

372
00:17:24,619 --> 00:17:27,880
అలా కాకపోతే, అప్పుడు ఉండవచ్చు తర్వాత నాతో మాట్లాడరు వచ్చి లేదా పోస్ట్

373
00:17:27,880 --> 00:17:29,595
CS50 న చర్చించి మేము ఆ క్రమం చేయవచ్చు.

374
00:17:34,510 --> 00:17:35,710
>> అన్ని కుడి.

375
00:17:35,710 --> 00:17:39,250
కాబట్టి ఇప్పుడు మేము అప్పుడు, మా రకమైన బేసిక్ టూల్స్ యొక్క కలిగి

376
00:17:39,250 --> 00:17:43,060
మారియో ప్రవేశిస్తాడు చేయవచ్చు.

377
00:17:43,060 --> 00:17:43,550
సరే.

378
00:17:43,550 --> 00:17:47,360
కాబట్టి మారియో మేము మాత్రం ఇక్కడ ముఖ్యంగా కార్యక్రమం

379
00:17:47,360 --> 00:17:50,800
మారియో యొక్క పురాతన వెర్షన్గా మా స్వంత రకం తయారు

380
00:17:50,800 --> 00:17:51,410
ఆట నేపథ్యంలో.

381
00:17:51,410 --> 00:17:54,790
మీకు తెలుసా, మారియో సాధారణంగా పైప్ మరియు ఒక ఉన్నాయి

382
00:17:54,790 --> 00:17:55,670
చెట్టు మరియు కొన్ని బ్లాక్స్.

383
00:17:55,670 --> 00:17:59,390
మరియు అప్పుడు సగం పిరమిడ్ ఒక రకమైన ఉంది.

384
00:17:59,390 --> 00:18:02,100
కాబట్టి, మనం కేవలం సగానికి పిరమిడ్ దృష్టి సారించడం కావడం చేస్తున్నారు

385
00:18:02,100 --> 00:18:05,350
ఎటువంటి కోసం hashes అవుట్ ముద్రిస్తుంది కోడ్ అటువంటి తయారు

386
00:18:05,350 --> 00:18:07,500
ఈ ఫార్మాట్ లో బ్లాకులను.

387
00:18:07,500 --> 00:18:10,800
కాబట్టి ఏమి జరుగుతుంది వినియోగదారు ఇన్పుట్ను కొంత ఉంటుంది

388
00:18:10,800 --> 00:18:13,130
పిరమిడ్ యొక్క ఎత్తు, మరియు అప్పుడు మీరు ఆ ప్రింట్ చేస్తాము

389
00:18:13,130 --> 00:18:17,410
దిగువన హాష్ వదిలి అలాంటి -

390
00:18:17,410 --> 00:18:21,270
చాలా దిగువన ఇక్కడే - ఒక align ఆ

391
00:18:21,270 --> 00:18:23,820
మీ టెర్మినల్ దిగువన ఎడమ తో.

392
00:18:26,720 --> 00:18:27,360
సరే.

393
00:18:27,360 --> 00:18:29,860
>> మీరు అవసరం కాబట్టి మొదటి విషయం -

394
00:18:29,860 --> 00:18:33,120
మేము పరిష్కరించడానికి అవసరమైన మొదటి చిన్న సమస్య ఎలా ఉంటుంది

395
00:18:33,120 --> 00:18:34,640
వినియోగదారు ఇన్పుట్ను పొందడానికి.

396
00:18:34,640 --> 00:18:40,020
కాబట్టి మేము వ్యవహరించే అవసరం ఏమి యూజర్ ఇన్పుట్లను మరియు తర్వాత

397
00:18:40,020 --> 00:18:41,060
అక్కడ ఉత్పత్తి విషయాల రకమైన.

398
00:18:41,060 --> 00:18:47,630
కాబట్టి యొక్క నేను రాసిన apples.c గా పిలువబడే ఒక ఫైల్ చూడండి చూద్దాం

399
00:18:47,630 --> 00:18:52,670
ఆ ఇన్పుట్లను మరియు ప్రతిఫలాన్ని వ్యవహరిస్తుంది.

400
00:18:52,670 --> 00:18:53,240
సరే.

401
00:18:53,240 --> 00:18:55,970
ఇక్కడ ఎగువ, నేను లైబ్రరీలను కొన్ని చేర్చాను

402
00:18:55,970 --> 00:18:56,540
నేను అవసరమైన.

403
00:18:56,540 --> 00:19:00,700
ఇక్కడ చాలా ముఖ్యమైనది ఒకటి (ప్రామాణిక I / O) stdio ఉంది. ఆ ఒప్పందాలు

404
00:19:00,700 --> 00:19:02,760
ప్రామాణిక ఇన్పుట్లను మరియు అవుట్పుట్లతో ఎందుకంటే మేము వెళుతున్నాం

405
00:19:02,760 --> 00:19:04,600
యూజర్ ఇన్పుట్లను వ్యవహరించే ఉంటుంది.

406
00:19:04,600 --> 00:19:04,960
అన్ని కుడి.

407
00:19:04,960 --> 00:19:06,660
కాబట్టి అప్పుడు నా ప్రధాన విధి ప్రారంభించండి.

408
00:19:06,660 --> 00:19:11,310
మరియు నేను సరే యూజర్ అడగండి మీరు ఎన్ని ఆపిల్ ఉన్నాయి?

409
00:19:11,310 --> 00:19:13,650
అప్పుడు ఇక్కడ, ఈ లైన్ దేనిని -

410
00:19:13,650 --> 00:19:18,420
నేను GetInt విలువకు వేరియబుల్ నేను కేటాయించండి.

411
00:19:18,420 --> 00:19:22,890
>> కాబట్టి GetInt stdio చేర్చారు ఒక విధి.

412
00:19:22,890 --> 00:19:26,090
కాబట్టి ముఖ్యంగా, మీరు దానిని పరిష్కరించేందుకు కనిపిస్తుంది.

413
00:19:26,090 --> 00:19:27,900
ఇది ఒక పూర్ణాంకానికి యూజర్ అడుగుతుంది.

414
00:19:27,900 --> 00:19:30,600
వారు తిరిగి ఏమైనా ఆ ఇవ్వబడతాయి

415
00:19:30,600 --> 00:19:32,020
నేను వేరియబుల్.

416
00:19:32,020 --> 00:19:35,620
కాబట్టి అప్పుడు ఇది తగ్గిస్తుంది ఒక చిన్న కార్యక్రమం

417
00:19:35,620 --> 00:19:39,160
1 i యొక్క విలువ మరియు తరువాత కొత్త విలువ అవుట్ ముద్రిస్తుంది.

418
00:19:39,160 --> 00:19:42,420
Gedit గురించి ఒక మంచి విషయం ఒక చిన్న ఉంది వాస్తవానికి

419
00:19:42,420 --> 00:19:43,720
ఇక్కడ టెర్మినల్ కుడి.

420
00:19:43,720 --> 00:19:46,670
కాబట్టి బదులుగా మధ్య ముందుకు మరియు వెనుకకు మారడం కలిగి

421
00:19:46,670 --> 00:19:48,120
gedit మరియు టెర్మినల్, మీరు వాస్తవానికి

422
00:19:48,120 --> 00:19:49,100
కేవలం ఇక్కడ నుండి అమలు.

423
00:19:49,100 --> 00:19:52,070
కాబట్టి కుడి డైరెక్టరీ పొందడానికి మొదటి చూద్దాం.

424
00:19:52,070 --> 00:19:54,230
కాబట్టి యొక్క మా డైరెక్టరీలు మార్చుకోవడానికి అనుమతించే

425
00:19:54,230 --> 00:19:55,480
Dropbox/walkthrough1.

426
00:19:57,160 --> 00:19:57,840
అన్ని కుడి.

427
00:19:57,840 --> 00:20:03,400
కాబట్టి ఇప్పుడు మా, యొక్క ఆపిల్ తయారు కూర్చింది తెలియజేయండి.

428
00:20:03,400 --> 00:20:06,640
కాబట్టి ఇప్పుడు యొక్క ఆపిల్ అమలు అనుమతిస్తాయి.

429
00:20:06,640 --> 00:20:08,420
మేము ఎన్ని ఆపిల్ ఉన్నాయి?

430
00:20:08,420 --> 00:20:09,630
నేను 3 కలిగి చెప్పారు.

431
00:20:09,630 --> 00:20:12,060
మరియు అది "నేను ఒక తినడానికి వెళుతున్న mwahaha" చెప్పాడు చెప్పారు

432
00:20:12,060 --> 00:20:13,610
"మీరు ఇప్పుడు 2 ఆపిల్".

433
00:20:13,610 --> 00:20:14,220
>> అన్ని కుడి.

434
00:20:14,220 --> 00:20:16,390
కాబట్టి యొక్క ఆ మళ్ళీ అమలు అనుమతిస్తాయి.

435
00:20:16,390 --> 00:20:19,040
మరియు లెట్స్ నేను 1 ఆపిల్ ఉన్నాయి, అవి.

436
00:20:19,040 --> 00:20:19,940
ఇప్పుడు నేను 0 ఆపిల్.

437
00:20:19,940 --> 00:20:20,180
సరే.

438
00:20:20,180 --> 00:20:22,460
కాబట్టి ఈ ప్రోగ్రామ్ అంచనా పని ఉంది.

439
00:20:22,460 --> 00:20:25,070
మేము ఇన్పుట్ సంఖ్య, అది 1 ద్వారా తగ్గుతుంది, మరియు

440
00:20:25,070 --> 00:20:27,290
మళ్ళీ దాన్ని ముద్రిస్తుంది.

441
00:20:27,290 --> 00:20:31,950
కాని ఉదాహరణకు, నేను -1 ఆపిల్, ఉంటే?

442
00:20:31,950 --> 00:20:33,440
అది చాలా సమంజసం అనిపించుకోదు.

443
00:20:33,440 --> 00:20:37,430
కాని ఇప్పటికీ ఒక పూర్ణాంకం యొక్క, ప్రోగ్రామ్ అంగీకరిస్తుంది కాబట్టి.

444
00:20:37,430 --> 00:20:41,090
మరియు అందువలన మీరు ఒక మరింత ప్రతికూల సంఖ్యను చూపిస్తుంది.

445
00:20:41,090 --> 00:20:44,700
కాబట్టి ఒక పాఠం మాకు కూడా అయితే GetInt

446
00:20:44,700 --> 00:20:46,700
ఫంక్షన్ మరియు ఇతర సంబంధం వాటిని

447
00:20:46,700 --> 00:20:48,260
GetFloat లేదా GetString -

448
00:20:48,260 --> 00:20:51,490
ఆ మాకు కుడి డేటా రకం పొందుతారు అయినప్పటికీ, కోసం

449
00:20:51,490 --> 00:20:55,750
ఉదాహరణకు, నేను చెప్పారు ఉంటే [టైప్],

450
00:20:55,750 --> 00:20:57,380
అప్పుడు మళ్ళీ నన్ను తెలియచేయును.

451
00:20:57,380 --> 00:21:01,860
కాబట్టి ఈ ఏ డేటా మీ ఇన్పుట్ టైప్ వ్యవహరించే కనిపిస్తుంది

452
00:21:01,860 --> 00:21:04,650
కానీ వాస్తవానికి తనిఖీ చెయ్యదు, బాగా, ఇది నిజానికి ఒక రకం

453
00:21:04,650 --> 00:21:07,820
నేను కావలసిన విలువ?

454
00:21:07,820 --> 00:21:12,370
కాబట్టి అప్పుడు మారియో యొక్క ఒక భాగం యూజర్ ఇన్పుట్ ఉంటుంది ఉంది

455
00:21:12,370 --> 00:21:15,400
సగం పిరమిడ్ యొక్క ఎత్తు ప్రాతినిధ్యం సంఖ్య

456
00:21:15,400 --> 00:21:16,360
మీరు చేస్తున్న ఆ.

457
00:21:16,360 --> 00:21:21,000
కాబట్టి అప్పుడు మేము ఎత్తు ఈ యూజర్ ప్రోత్సహించాడు అప్పుడు మీరు

458
00:21:21,000 --> 00:21:25,480
ఈ రెండు హద్దులు ఉండాలి.

459
00:21:25,480 --> 00:21:28,040
కుడి?

460
00:21:28,040 --> 00:21:31,150
స్పెక్ లో, ఇది కంటే ఎక్కువ 23 ఉండకూడదు చెప్పారు

461
00:21:31,150 --> 00:21:32,630
ప్రామాణిక రకం పాత్రలు ఎందుకంటే

462
00:21:32,630 --> 00:21:34,450
టెర్మినల్ యొక్క ఎత్తు.

463
00:21:34,450 --> 00:21:37,590
కానీ, BOUND ఇతర ఏ, బహుశా తక్కువ కట్టుబడి వాటిని

464
00:21:37,590 --> 00:21:38,840
మేము ఉన్నాయి అనుకుంటున్నారా?

465
00:21:41,180 --> 00:21:44,350
>> మేము నిజంగా తిరిగి ఆలోచిస్తూ ఒక పిరమిడ్, రకం గీయడం ఉంటే

466
00:21:44,350 --> 00:21:48,460
ఒక పిరమిడ్ ఎలా అధిక, ఇది ఒక కంటే తక్కువగా ఉంటుంది కు

467
00:21:48,460 --> 00:21:49,132
నిర్దిష్ట సంఖ్యలో?

468
00:21:49,132 --> 00:21:50,490
SPEAKER 2: మూడు కంటే పెద్దది.

469
00:21:50,490 --> 00:21:50,560
ZAMYLA చాన్: అయ్యో?

470
00:21:50,560 --> 00:21:52,630
SPEAKER 2: మూడు కంటే పెద్దది.

471
00:21:52,630 --> 00:21:54,850
ZAMYLA చాన్: ఒక మంచి పాయింట్.

472
00:21:54,850 --> 00:21:57,860
ఎంత -

473
00:21:57,860 --> 00:22:00,700
మేము కేవలం మూడు స్థాయి పిరమిడ్ కి పరిమితం చేయవచ్చు.

474
00:22:00,700 --> 00:22:02,120
కానీ లెట్స్ ఆలోచన -

475
00:22:02,120 --> 00:22:06,510
లెట్స్ కూడా పిరమిడ్ వంటి ఒక హాష్ పట్టిక గణనలు వంటి చెప్పారు.

476
00:22:06,510 --> 00:22:09,031
అప్పుడు మా అసలు తక్కువ బౌండ్ ఉండాలి?

477
00:22:12,260 --> 00:22:13,760
తిరిగి ఆపిల్ ఆలోచిస్తే, మేము ఒక చేయకూడదని

478
00:22:13,760 --> 00:22:15,020
ప్రతికూల ఎత్తు పిరమిడ్.

479
00:22:15,020 --> 00:22:15,460
కుడి?

480
00:22:15,460 --> 00:22:15,720
సరే.

481
00:22:15,720 --> 00:22:19,060
కాబట్టి మీరు వినియోగదారు ఇన్పుట్ కోసం అడిగినప్పుడు, మీరు ఉంటుంది

482
00:22:19,060 --> 00:22:21,980
పూర్ణాంక ఆ నిర్ధారించాడు విధంగా ఉన్నాయి

483
00:22:21,980 --> 00:22:24,970
మీరు కాదు ఎందుకంటే ప్రతికూల కాదు వారు మీరు అందించే

484
00:22:24,970 --> 00:22:28,180
ఒక ప్రతికూల పిరమిడ్ డ్రా.

485
00:22:28,180 --> 00:22:28,410
>> సరే.

486
00:22:28,410 --> 00:22:30,190
కాబట్టి దీన్ని రెండు మార్గాలు ఉన్నాయి.

487
00:22:30,190 --> 00:22:34,420
ముఖ్యంగా, మీరు వినియోగదారు ఇన్పుట్ కోసం అడగవద్దు, మీరు డిమాండ్ మీరు

488
00:22:34,420 --> 00:22:37,080
వారు సరైన ఇన్పుట్ మీకు అందించే.

489
00:22:37,080 --> 00:22:40,120
కాబట్టి వారు అనేక మీకు అందించే డిమాండ్ మీరు

490
00:22:40,120 --> 00:22:46,630
ప్రతికూల కానీ 24 కంటే తక్కువ కాదు.

491
00:22:46,630 --> 00:22:49,510
కాబట్టి మేము సున్నాకి 23, కలుపుకొని వ్యవహరించే చేస్తున్నారు.

492
00:22:49,510 --> 00:22:50,070
అన్ని కుడి.

493
00:22:50,070 --> 00:22:52,830
కాబట్టి మేము నిరంతరం డిమాండ్ ఎంచుకోండి -

494
00:22:52,830 --> 00:22:55,720
వారు మాకు ఒక చెల్లుబాటు అయ్యే పూర్ణాంక ఇచ్చిన ఉండకపోతే, వారు మీరు

495
00:22:55,720 --> 00:22:57,350
నిరంతరం ఏ డిమాండ్.

496
00:22:57,350 --> 00:22:59,770
నాకు చెల్లుబాటు అయ్యే ఇన్పుట్ ఇవ్వండి.

497
00:22:59,770 --> 00:23:02,270
నాకు చెల్లుబాటు అయ్యే ఎత్తు ఇవ్వండి.

498
00:23:02,270 --> 00:23:06,970
కాబట్టి తిరిగి స్క్రాచ్ లో గుర్తు, మేము లేదా బ్లాక్ వరకు రిపీట్ కలిగి

499
00:23:06,970 --> 00:23:08,950
బ్లాక్ ఉంటే ఫరెవర్.

500
00:23:08,950 --> 00:23:12,345
ఆ సమయంలో చాలా లూప్ వలె మరియు అని ఉచ్చులు ఉన్నాయి

501
00:23:12,345 --> 00:23:14,960
అయితే మేము ఒక క్షణంలో లోకి పొందుతారు ఇది లూప్,.

502
00:23:14,960 --> 00:23:19,790
కాబట్టి లూప్ ముఖ్యంగా మీరు తనిఖీ చేసే ఒక పరిస్థితి ఉంది

503
00:23:19,790 --> 00:23:23,240
ఆ వంటి, మీరు అక్కడ లోపల ఉంచిన బూలియన్ విలువ ఏమిటి

504
00:23:23,240 --> 00:23:25,740
మొగ్గుచూపింది స్క్రాచ్ లో బ్లాక్స్.

505
00:23:25,740 --> 00:23:29,550
ఆ సమయంలో లూప్ యొక్క బ్రాకెట్లలో లోపల వెళుతుంది ఏమిటి.

506
00:23:29,550 --> 00:23:31,830
కాబట్టి మీరు అక్కడ పరిస్థితి రకమైన కలిగి ఉంటుంది.

507
00:23:31,830 --> 00:23:36,540
మేము ముందుగా చర్చించిన మరియు, ఆ పరిస్థితి రెడీ

508
00:23:36,540 --> 00:23:40,250
ఇన్పుట్ ఆ పూర్ణాంక యొక్క సరిహద్దులు తో చేయాలి.

509
00:23:40,250 --> 00:23:44,040
కాబట్టి పరిస్థితి అని తో ఏదైనా కలిగి ఉంటుంది

510
00:23:44,040 --> 00:23:48,600
పూర్ణాంక తగిన హద్దుల్లో ఉంది.

511
00:23:48,600 --> 00:23:49,410
>> కాబట్టి ఒక సమయంలో లూప్ ఉంది.

512
00:23:49,410 --> 00:23:52,580
ఉదాహరణకు, మీరు పూర్ణాంక కోసం ప్రేరేపిస్తుంది మరియు చేయవచ్చు

513
00:23:52,580 --> 00:23:56,070
ఈ ఇన్పుట్ చెల్లదు అయితే నిరంతరం తనిఖీ.

514
00:23:56,070 --> 00:23:59,810
ఉదాహరణకు, తిరిగి ప్రాంప్ట్ చేస్తూనే, అడగడం చేస్తూనే

515
00:23:59,810 --> 00:24:01,600
పూర్ణాంకం కోసం వినియోగదారు.

516
00:24:01,600 --> 00:24:03,780
కాబట్టి ఒక మార్గంలో ఉంటుంది.

517
00:24:03,780 --> 00:24:06,240
లూప్, ఇది చాలా ఉంది మరొక మార్గంగా డో ఉంటుంది

518
00:24:06,240 --> 00:24:10,130
ఉన్నప్పటికీ ఏమి ఒక తప్ప కొంత లూప్ పోలి ఉంటుంది -

519
00:24:10,130 --> 00:24:12,600
మీరు రకమైన వాక్యనిర్మాణం ద్వారా చూడగలరు -

520
00:24:12,600 --> 00:24:18,540
ఇది మొదట డో మరియు వాస్తవ లూప్ శరీరం కలిగి ఉంది.

521
00:24:18,540 --> 00:24:20,280
అప్పుడు పరిస్థితులు ఉన్నాయి.

522
00:24:20,280 --> 00:24:22,060
సో వాట్ ఉచ్చులు సమయంలో -

523
00:24:22,060 --> 00:24:25,470
వారు ఉపయోగకరంగా ఉన్నారు వారు నిజానికి అమలు ఉంది

524
00:24:25,470 --> 00:24:29,130
కోడ్ కనీసం ఒకసారి మరియు అప్పుడు పరిస్థితి లేదో తనిఖీ

525
00:24:29,130 --> 00:24:30,030
కలుసుకున్నారు లేదా.

526
00:24:30,030 --> 00:24:32,510
మీరు లూప్ అయితే, అప్పుడు లోపల ఏమి చేయాలి కు అలా అయితే మీ

527
00:24:32,510 --> 00:24:35,210
మీరు వద్ద చేస్తాము ఎందుకంటే ప్రకటన మీరు పూర్ణాంకం కోసం ప్రేరేపిస్తుంది

528
00:24:35,210 --> 00:24:37,180
కనీసం ఒకసారి యూజర్ గోవా.

529
00:24:37,180 --> 00:24:40,850
మీరు వాటిని ప్రాంప్ట్ తర్వాత, మీరు, సరే చెప్పగలదు

530
00:24:40,850 --> 00:24:43,110
అలాగే ఒకసారి నేను ఇది చేసిన, ఇది చెల్లుబాటు అవుతుందా?

531
00:24:43,110 --> 00:24:44,810
అది ఉంటే, అప్పుడు మీరు వెళ్లి యుండును.

532
00:24:44,810 --> 00:24:47,310
ఇది అయితే, అది కేవలం ఒక సాధారణ ప్రవర్తిస్తాయి చేస్తాము

533
00:24:47,310 --> 00:24:49,240
లూప్ మరియు తరువాత అడుగుతూ ఉంటాను.

534
00:24:53,590 --> 00:24:54,670
>> సరే.

535
00:24:54,670 --> 00:24:57,120
కాబట్టి మేము మారియో తిరిగి ఉన్నారు.

536
00:24:57,120 --> 00:25:01,740
కాబట్టి మేము అని సరైన యూజర్ ఇన్పుట్ కోసం వేచి ఎలా

537
00:25:01,740 --> 00:25:03,160
కుడివైపు హద్దుల్లో.

538
00:25:03,160 --> 00:25:07,100
కాబట్టి ఇప్పుడు మేము నిజానికి ఈ సగం పిరమిడ్ డ్రా అవసరం.

539
00:25:07,100 --> 00:25:08,730
ఇది సాధారణ టెక్స్ట్ అక్షరాలు కనిపిస్తోంది.

540
00:25:08,730 --> 00:25:10,360
కాబట్టి యొక్క వాస్తవానికి ఓపెన్ అనుమతిస్తుంది -

541
00:25:14,280 --> 00:25:17,190
యొక్క ఒక విండో తెరిచి, సరే అని పిలవబడు, మరియు నేను ఏమి అయితే

542
00:25:17,190 --> 00:25:24,960
వాస్తవానికి మానవీయంగా అది చేయబోవడం, ఒక నేను టైప్?

543
00:25:24,960 --> 00:25:25,780
సరే.

544
00:25:25,780 --> 00:25:26,910
కాబట్టి యొక్క చూసేలా.

545
00:25:26,910 --> 00:25:30,070
ఉదాహరణకు, అని పిలవబడు యొక్క, మేము ఉన్న ఒక పిరమిడ్ అనుకున్న

546
00:25:30,070 --> 00:25:32,090
ఎడమవైపు మండలం, అప్పుడు అని -

547
00:25:34,710 --> 00:25:37,750
మారియో లో, అగ్ర స్థాయిలో ఒకటి బదులు రెండు బ్లాకుల ఉంది.

548
00:25:37,750 --> 00:25:39,080
కాబట్టి మేము రెండు ప్రారంభం.

549
00:25:39,080 --> 00:25:40,700
మేము Enter ని క్లిక్ చెయ్యండి.

550
00:25:40,700 --> 00:25:45,670
మేము ఐదు నమోదు చేయండి, తరువాత నాలుగు మూడు చేయండి, మరియు.

551
00:25:45,670 --> 00:25:45,980
సరే.

552
00:25:45,980 --> 00:25:46,790
కాబట్టి ఆ అందంగా సులభం.

553
00:25:46,790 --> 00:25:50,210
ఈ సమస్య సెట్ లో తప్ప, మేము కలుస్తాయి వాస్తవానికి అది కావాలి

554
00:25:50,210 --> 00:25:52,250
మా స్క్రీన్ కుడివైపు.

555
00:25:52,250 --> 00:25:52,630
అన్ని కుడి.

556
00:25:52,630 --> 00:25:58,870
కాబట్టి, ఎలా మీరు ఒక నిజానికి ఈ అటువంటి టైపు చేయవచ్చు

557
00:25:58,870 --> 00:26:01,810
అది కుడి పాటు మండలం యొక్క?

558
00:26:01,810 --> 00:26:08,550
బదులుగా మొదటి హాష్ ఉంచడం యొక్క, ఎలా మీరు రకమైన వాటిని

559
00:26:08,550 --> 00:26:10,040
అది వెంట తరలించాలా?

560
00:26:10,040 --> 00:26:11,360
SPEAKER 3: ఒక లైన్ వ్రాయండి?

561
00:26:11,360 --> 00:26:11,800
ZAMYLA చాన్: అయ్యో?

562
00:26:11,800 --> 00:26:13,030
SPEAKER 3: ఒక లైన్ వ్రాయండి?

563
00:26:13,030 --> 00:26:13,110
ZAMYLA చాన్: అవును.

564
00:26:13,110 --> 00:26:13,390
అవును.

565
00:26:13,390 --> 00:26:15,080
మీరు ఒక వలె రాస్తుంది తక్కువగా లేదా ఏదో వంటి కాలేదు

566
00:26:15,080 --> 00:26:19,370
ఆ, అయితే మేము ఒక స్పేస్ ఉపయోగించే చెప్పగలను.

567
00:26:19,370 --> 00:26:21,500
యొక్క ఇక్కడ మూడు ఖాళీలు వంటి ఉంచారు లెట్.

568
00:26:21,500 --> 00:26:24,760
తరువాతి లైన్, బాగా, మేము రెండు ఖాళీలు ఉంచాలి చేస్తుంది.

569
00:26:24,760 --> 00:26:26,500
తదుపరి లైన్, మేము కేవలం ఒక ఖాళీ ఉంచండి.

570
00:26:26,500 --> 00:26:30,340
మరియు తర్వాత మా చివరి పంక్తి కోసం, మేము ఏ స్పేస్ పెట్టి లేదు.

571
00:26:30,340 --> 00:26:32,210
మరియు అక్కడ మేము మా పిరమిడ్ ఉన్నాయి.

572
00:26:32,210 --> 00:26:33,170
>> కాబట్టి ఆ రకమైన ఉంది -

573
00:26:33,170 --> 00:26:37,290
తర్కం ఆ రకమైన గుర్తు.

574
00:26:37,290 --> 00:26:39,340
మరియు ప్రయత్నించండి మరియు మేము నమూనా యొక్క కొన్ని రకమైన గుర్తించడానికి

575
00:26:39,340 --> 00:26:43,690
అప్పుడు సి అనువదించు మరియు లూప్ ఒకరకమైన ఉంటాయి.

576
00:26:43,690 --> 00:26:43,930
అన్ని కుడి.

577
00:26:43,930 --> 00:26:48,130
కాబట్టి మేము ఒక ఎత్తు ఎనిమిది ఉన్నాయి, అవి, అప్పుడు మా మొదటి వరుస ఉంటుంది

578
00:26:48,130 --> 00:26:48,980
రెండు hashes.

579
00:26:48,980 --> 00:26:53,030
కానీ ఆ hashes పొందడానికి, మీరు కొన్ని వ్రాసి వుంటుంది

580
00:26:53,030 --> 00:26:54,000
ముందుగానే స్థలాలు.

581
00:26:54,000 --> 00:26:55,840
కుడి?

582
00:26:55,840 --> 00:26:57,340
నేను చేసిన నేను పొందాను ఉంది.

583
00:26:57,340 --> 00:27:00,150
నేను, నా టెక్స్ట్ ఎడిటర్ లో, నాకు అవ్ట్ ఒక పిరమిడ్ ఇది ఆకర్షించింది ఒక

584
00:27:00,150 --> 00:27:03,800
ఎనిమిది యొక్క ఎత్తు పిరమిడ్ మరియు తరువాత లెక్కిస్తారు ఎన్ని

585
00:27:03,800 --> 00:27:05,180
నేను అవసరమైన స్థలాలు.

586
00:27:05,180 --> 00:27:07,350
నేను సరే, అలాగే మొదటి వరుస చెప్పాడు

587
00:27:07,350 --> 00:27:08,260
రెండు hashes కొనసాగుతుందని.

588
00:27:08,260 --> 00:27:11,100
కానీ ముందు, నేను ఇన్పుట్ ఏడు ఖాళీలు అవసరం.

589
00:27:11,100 --> 00:27:13,420
తదుపరి ఆరు ఖాళీలను ఆపై ఉంది

590
00:27:13,420 --> 00:27:15,610
మూడు hashes, et సెటేరా.

591
00:27:15,610 --> 00:27:20,520
>> కాబట్టి అప్పుడు యొక్క ప్రయత్నించండి మరియు మరొక పొర ఈ తీసుకుని తెలియజేయండి

592
00:27:20,520 --> 00:27:21,330
సంగ్రహణం.

593
00:27:21,330 --> 00:27:26,680
మనం nth వరుస కోసం ఉన్నట్లయితే, ఎన్ని hashes మరియు ఎలా

594
00:27:26,680 --> 00:27:27,960
మేము అనేక ప్రదేశాలు అవసరం?

595
00:27:27,960 --> 00:27:30,750
ఎవరైనా నమూనా చూడండి లేదు?

596
00:27:35,200 --> 00:27:37,560
కాబట్టి మొదటి వరుసలో రెండు hashes ఉంది.

597
00:27:37,560 --> 00:27:39,720
రెండవ మూడు ఉన్నాయి.

598
00:27:39,720 --> 00:27:42,120
మూడవ నాలుగు ఉన్నాయి.

599
00:27:42,120 --> 00:27:45,398
కాబట్టి nth వరుస ఉంటుంది -

600
00:27:45,398 --> 00:27:46,800
SPEAKER 4: N ప్లస్ 1?

601
00:27:46,800 --> 00:27:47,170
ZAMYLA చాన్: అవును.

602
00:27:47,170 --> 00:27:47,780
N ప్లస్ 1.

603
00:27:47,780 --> 00:27:49,030
సరిగ్గా.

604
00:27:52,810 --> 00:27:56,470
కాబట్టి అప్పుడు మేము hashes సంఖ్య మాత్రం ఆ చూడండి -

605
00:27:56,470 --> 00:27:59,510
మేము ఒకటిగా మొదటి వరుస లెక్కింపు చేస్తుంటే, అప్పుడు సంఖ్య

606
00:27:59,510 --> 00:28:03,850
hashes కేవలం కంటే ఒకటి అని అన్నారు.

607
00:28:03,850 --> 00:28:04,150
సరే.

608
00:28:04,150 --> 00:28:06,350
కాబట్టి అప్పుడు ఏమి ఖాళీలు సంఖ్య సుమారు?

609
00:28:06,350 --> 00:28:10,120
కాబట్టి యొక్క ప్రయత్నించండి మరియు ఎత్తు పరంగా దీనిని తెలియజేయండి.

610
00:28:10,120 --> 00:28:12,570
ఎత్తు మొదటి అప్పుడు, ఎనిమిది ఉంటే

611
00:28:12,570 --> 00:28:15,260
వరుస ఏడు ప్రదేశములు ఉన్నాయి.

612
00:28:15,260 --> 00:28:18,215
సమంగా యొక్క కాబట్టి ఆ తరహా 8 మైనస్ 1.

613
00:28:18,215 --> 00:28:19,030
కుడి?

614
00:28:19,030 --> 00:28:22,420
కాబట్టి అప్పుడు రెండవ వరుసలో ఆరు స్థలాలు అన్నారు,

615
00:28:22,420 --> 00:28:25,340
ఇది 8 మైనస్ 2.

616
00:28:28,420 --> 00:28:31,450
కాబట్టి నేను బొమ్మ రకం అవుట్ మీరు దానిని వదిలి వెళుతున్న

617
00:28:31,450 --> 00:28:33,610
ఆ కోసం నమూనా.

618
00:28:33,610 --> 00:28:34,010
>> సరే.

619
00:28:34,010 --> 00:28:37,450
సున్నా వద్ద కానీ ప్రోగ్రామింగ్ లో, కొన్నిసార్లు మేము నిజంగా సూచిక.

620
00:28:37,450 --> 00:28:39,680
కాబట్టి మేము ఒకటి బదులు సున్నా వద్ద ప్రారంభించండి.

621
00:28:39,680 --> 00:28:46,250
కాబట్టి బదులుగా మొదటి వరుస పిలువబడే మొదటి వరుస యొక్క,

622
00:28:46,250 --> 00:28:48,930
మేము అది 0-th వరుస కాల్ కావడం చేస్తున్నారు.

623
00:28:48,930 --> 00:28:51,360
కాబట్టి మీరు దాన్ని అమలు చేయదలిచిన మీద ఆధారపడి ఉంటుంది

624
00:28:51,360 --> 00:28:55,120
మీరు వద్ద మొదలు లేదో సున్నా వద్ద మొదలు అని చాలా జాగ్రత్తగా

625
00:28:55,120 --> 00:28:58,400
ఒక, మీ నమూనా ఒకటి ఆఫ్సెట్ చేస్తాడు.

626
00:29:02,270 --> 00:29:02,880
సరే.

627
00:29:02,880 --> 00:29:05,460
కాబట్టి ఇప్పుడు మేము రకమైన కార్యక్రమం కనుగొన్నారు, మనం

628
00:29:05,460 --> 00:29:06,310
సరే చెప్పే.

629
00:29:06,310 --> 00:29:11,540
కాబట్టి మెట్లు స్థాయి ప్రతీ నేను ప్రింట్ వెళుతున్న

630
00:29:11,540 --> 00:29:14,390
అటువంటి మరియు ఖాళీలు ఇటువంటి సంఖ్య మరియు తరువాత అటువంటి మరియు

631
00:29:14,390 --> 00:29:16,550
hashes ఇటువంటి సంఖ్య.

632
00:29:16,550 --> 00:29:19,550
అంటే ముందు ఏర్పాటు చేసిన నమూనా మీద ఆధారపడి ఉంటుంది.

633
00:29:19,550 --> 00:29:19,810
సరే.

634
00:29:19,810 --> 00:29:23,600
వెళ్ళటం కాబట్టి ద్వారా iterating యొక్క మార్గం మరియు రకం

635
00:29:23,600 --> 00:29:27,670
విషయాలను సెట్ సంఖ్య ద్వారా లూప్, రకమైన వంటి కోసం

636
00:29:27,670 --> 00:29:31,040
రిపీట్ 10 బ్లాక్ లేదా వంటి రిపీట్ మరియు మీరు నమోదు ఒక

637
00:29:31,040 --> 00:29:33,810
స్క్రాచ్ కోసం సంఖ్య.

638
00:29:33,810 --> 00:29:38,050
కాబట్టి ముఖ్యంగా, మెట్లు ప్రతి స్థాయికి, మేము చెయ్యవచ్చును

639
00:29:38,050 --> 00:29:39,650
మొదటి స్పేస్ ప్రింట్.

640
00:29:39,650 --> 00:29:43,020
అప్పుడు hashes సంఖ్య ప్రింట్.

641
00:29:43,020 --> 00:29:46,480
మరియు తర్వాత మేము ఒక కొత్త పంక్తిని నమోదు చేసి, ఆపై మళ్ళీ చెయ్యవచ్చును

642
00:29:46,480 --> 00:29:49,750
మళ్లీ తదుపరి బ్లాక్ కోసం.

643
00:29:49,750 --> 00:29:50,720
సరే.

644
00:29:50,720 --> 00:29:55,080
>> కాబట్టి ఒక మార్గం చూడండి యొక్క రకమైన ఒక క్షణ కోసం ఉచ్చులు కోసం చూద్దాం

645
00:29:55,080 --> 00:29:59,460
మేము ఒక నిర్దిష్ట సంఖ్యలో ద్వారా వెళ్ళవచ్చు ఆ, సంఖ్య ద్వారా వెళ్ళి

646
00:29:59,460 --> 00:30:02,250
ఈ సగం పిరమిడ్ లో దశలను.

647
00:30:02,250 --> 00:30:04,220
కాబట్టి ఉచ్చులు కోసం మూడు భాగాలు తయారు చేస్తారు.

648
00:30:04,220 --> 00:30:08,150
మొదట, మీరు ఒక ప్రారంభ ఉన్నాయి.

649
00:30:08,150 --> 00:30:13,220
కాబట్టి ఆ ముఖ్యంగా వేరియబుల్ అమర్చుతుంది.

650
00:30:13,220 --> 00:30:15,130
ఆ విలువ ప్రతి సమయం సెట్ చేస్తాడు

651
00:30:15,130 --> 00:30:17,110
ఆ లూప్ ప్రారంభాల్లో కోసం.

652
00:30:17,110 --> 00:30:18,540
అప్పుడు మీకు ఒక పరిస్థితి చూడాలని.

653
00:30:18,540 --> 00:30:21,640
మీ కోసం లూప్ మాత్రమే కాలం అమలు అవుతుంది

654
00:30:21,640 --> 00:30:25,630
పరిస్థితి ఒప్పుకు మదింపు.

655
00:30:25,630 --> 00:30:28,000
ఆపై మీరు ఒక నవీకరణ పరిస్థితి ఉంటుంది.

656
00:30:28,000 --> 00:30:32,450
తద్వారా మీరు initialized ఆ వేరియబుల్ సంబంధం కలిగి ఉంటుంది.

657
00:30:32,450 --> 00:30:38,120
ప్రధానంగా మేము బయటకు హామీ ఇచ్చే యొక్క కాబట్టి కొన్ని మార్గం

658
00:30:38,120 --> 00:30:40,070
లూప్ యొక్క, మేము అమలు ఉంచవద్దు

659
00:30:40,070 --> 00:30:41,310
అది ఎప్పటికీ మరియు ఎప్పుడూ.

660
00:30:41,310 --> 00:30:43,760
స్క్రాచ్ కాకుండా, మేము నిజానికి ఒక లేవు

661
00:30:43,760 --> 00:30:45,680
సాదా ఫరెవర్ లూప్.

662
00:30:45,680 --> 00:30:48,100
సి లో, చివరిగా ఈ కార్యక్రమం పూర్తి ఉంటుంది.

663
00:30:48,100 --> 00:30:52,290
కాబట్టి మేము కొన్ని మార్గం మేము దీనిని ఆపే ఉండడం అవసరం.

664
00:30:52,290 --> 00:30:52,830
>> సరే.

665
00:30:52,830 --> 00:30:56,260
కాబట్టి మీరు ఉపయోగించాలనుకుంటున్న అని లూప్ ఒక ఉదాహరణ

666
00:30:56,260 --> 00:30:57,530
మారియో ఈ ఉంది.

667
00:30:57,530 --> 00:31:02,290
కాబట్టి మీరు 0 వద్ద ప్రారంభించండి నేను పూర్ణాంకం ఉన్నాయి.

668
00:31:02,290 --> 00:31:08,050
కాలం అది ఎత్తు కంటే తక్కువగా ఉంటుంది, మీరు శరీరం అమలు

669
00:31:08,050 --> 00:31:11,140
ఇక్కడ లోపల లూప్ యొక్క.

670
00:31:11,140 --> 00:31:13,820
లూప్ అని అమలు తర్వాత, మీరు ఆ

671
00:31:13,820 --> 00:31:15,290
1 i పెంచుతాయి.

672
00:31:15,290 --> 00:31:18,510
అప్పుడు మీ ప్రోగ్రామ్ మళ్ళీ తనిఖీ చేస్తాడు - సరే, నేను కంటే తక్కువ ఉంటుంది

673
00:31:18,510 --> 00:31:18,885
ఎత్తు?

674
00:31:18,885 --> 00:31:21,865
అది ఉంటే, అప్పుడు మీరు కొనసాగింది.

675
00:31:24,630 --> 00:31:27,790
కాబట్టి ఇక్కడ వద్ద ప్రారంభం సున్నా ఇండెక్సింగ్, యొక్క ఉదాహరణకు

676
00:31:27,790 --> 00:31:29,100
సున్నా తరువాత మేము -

677
00:31:29,100 --> 00:31:30,970
మా పరిస్థితి ఎత్తు కంటే తక్కువగా ఉంది అని గుర్తించలేకపోతే.

678
00:31:30,970 --> 00:31:34,510
మా ఎత్తు ఉదాహరణకు, నాలుగు అంటారు, నేను

679
00:31:34,510 --> 00:31:35,470
0 వద్ద ప్రారంభమవుతుంది.

680
00:31:35,470 --> 00:31:36,180
ఇది 1 ఉంటాం.

681
00:31:36,180 --> 00:31:36,730
ఇది 2 ఉంటాం.

682
00:31:36,730 --> 00:31:37,940
ఇది 3 ఉంటాం.

683
00:31:37,940 --> 00:31:42,310
మరియు తర్వాత ఇది లూప్ నవీకరణల కోసం, నేను రెడీ చేస్తే,

684
00:31:42,310 --> 00:31:43,650
అప్పుడు 4 కు సెట్.

685
00:31:43,650 --> 00:31:47,080
కానీ 4 కంటే తక్కువ 4 కాదు, అందువలన అప్పుడు మనం

686
00:31:47,080 --> 00:31:50,340
మా లూప్ మిగిలిన కొనసాగుతుంది.

687
00:31:50,340 --> 00:31:50,870
>> సరే.

688
00:31:50,870 --> 00:31:51,680
కాబట్టి ఆ సున్నా వద్ద ప్రారంభమై యొక్క.

689
00:31:51,680 --> 00:31:53,470
కానీ మేము ఉదాహరణకు, ఒక వద్ద మొదలు కాలేదు.

690
00:31:53,470 --> 00:31:56,960
మేము ఒక వద్ద ప్రారంభం నుంచి, మేము విధమైన మరింత వెళ్ళాలి

691
00:31:56,960 --> 00:31:57,920
ముగింపు సమయంలో.

692
00:31:57,920 --> 00:32:02,800
మేము కంటే తక్కువ లేదా సమానం జోడించండి వై సో అప్పుడు ఆ.

693
00:32:02,800 --> 00:32:05,780
నేను కంప్యూటర్ కి సంబంధించిన గొప్ప విషయాలు ఒకటి

694
00:32:05,780 --> 00:32:06,930
ప్రోగ్రామింగ్ కేవలం అక్కడ ఉంది

695
00:32:06,930 --> 00:32:08,370
పనులు చాలా మార్గాలు.

696
00:32:08,370 --> 00:32:11,300
కాబట్టి మీరు, సున్నా వద్ద మీరు ప్రారంభించడానికి ఎంచుకోవచ్చు మీరు లేదో చేయవచ్చు

697
00:32:11,300 --> 00:32:12,330
ఒక ప్రారంభమవుతాయి.

698
00:32:12,330 --> 00:32:15,400
మీరు కోరుకుంటే కూడా, మీరు ఒక ఉపయోగించవచ్చు

699
00:32:15,400 --> 00:32:16,600
అయితే ఉదాహరణకు లూప్,.

700
00:32:16,600 --> 00:32:18,890
కాబట్టి మీరు కాలేదు -

701
00:32:18,890 --> 00:32:20,270
వాస్తవానికి ఓపెన్ hello.c చూద్దాం.

702
00:32:26,200 --> 00:32:28,600
కాబట్టి మేము ఇక్కడ లూప్ ఒక ఉంటాయి.

703
00:32:28,600 --> 00:32:31,330
నేను = 0, i <5 మొదలవుతుంది.

704
00:32:31,330 --> 00:32:33,550
నేను ఏమి మాకు చెప్పినందుకు ఇక్కడ వ్యాఖ్య ఉందా.

705
00:32:33,550 --> 00:32:36,300
ఇది హలో లూప్ ఒక ఉపయోగించి, ఐదు సార్లు ముద్రిస్తుంది.

706
00:32:36,300 --> 00:32:41,690
కానీ మేము కూడా కొంత లూప్ ఉపయోగించి ఆ పని చేయడు.

707
00:32:41,690 --> 00:32:48,290
>> కాబట్టి యొక్క మేము అలా ఎలా చూద్దాం.

708
00:32:48,290 --> 00:32:51,010
మేము లూప్ ఒక అనుకరించేందుకు వెళుతున్న అయితే, అప్పుడు మేము కూడా మీరు

709
00:32:51,010 --> 00:32:54,870
ప్రారంభ, పరిస్థితి, మరియు నవీకరణ అనుకరిస్తాయి.

710
00:32:54,870 --> 00:33:01,430
కాబట్టి పరిస్థితి ఎందుకంటే, చాలా సులభమైన ఉండాలి

711
00:33:01,430 --> 00:33:04,350
వాక్యనిర్మాణం, అయితే అయితే (పరిస్థితి), మీరు చూడండి, అది చెప్పింది.

712
00:33:04,350 --> 00:33:06,830
సో అక్కడ కేవలం ఇన్పుట్ పరిస్థితి చూద్దాం.

713
00:33:06,830 --> 00:33:09,700
i <5.

714
00:33:09,700 --> 00:33:10,590
సరే.

715
00:33:10,590 --> 00:33:18,900
కనుక మేము వీడ్కోలు ముద్రించడానికి కావలసిన తెలుసు.

716
00:33:18,900 --> 00:33:21,350
మేము మా లూప్ యొక్క శరీరం మనకు తెలుసు.

717
00:33:21,350 --> 00:33:23,600
కానీ మేము ప్రారంభ లేదు చేస్తున్నారు

718
00:33:23,600 --> 00:33:24,490
మరియు నవీకరణ, కుడి?

719
00:33:24,490 --> 00:33:25,790
మేము ఒక శాశ్వతంగా లూప్ లేదు ఎందుకంటే.

720
00:33:25,790 --> 00:33:27,660
ఇది అంతం ఉంటుంది.

721
00:33:27,660 --> 00:33:35,300
కాబట్టి యొక్క ఉపయోగించి ఇక్కడ ప్రారంభ రకమైన జోడించడానికి అనుమతిస్తుంది

722
00:33:35,300 --> 00:33:38,790
మేము మా కోసం లూప్ లో ఉపయోగించిన అదే ఒక, Int i = 0.

723
00:33:38,790 --> 00:33:39,110
సరే.

724
00:33:39,110 --> 00:33:40,630
కాబట్టి మేము ఒక పూర్ణాంకానికి నేను ప్రారంభం.

725
00:33:40,630 --> 00:33:43,640
మేము i కంటే తక్కువ 5 ఉన్నంత వరకు ఈ సమయంలో లూప్ పునరావృతం.

726
00:33:43,640 --> 00:33:47,220
కాబట్టి అప్పుడు మేము నవీకరణ ఇది ఒక విషయం, కోల్పోతున్నారు.

727
00:33:47,220 --> 00:33:51,470
సో వాట్ నవీకరణ మేము తప్పనిసరిగా అయితే ఉపయోగించడానికి అవసరం

728
00:33:51,470 --> 00:33:52,880
పైన లూప్ పునః?

729
00:33:56,000 --> 00:33:59,880
మేము i 0 సమానం ప్రారంభ ఉన్నాయి.

730
00:33:59,880 --> 00:34:03,610
మేము నేను 5 కంటే తక్కువ పరిస్థితిని.

731
00:34:03,610 --> 00:34:06,300
మరియు ఇక్కడ కుడి, ఒక నవీకరణ ఏమిటి?

732
00:34:06,300 --> 00:34:07,365
కాబట్టి మేము ఆ కాపీ మీరు.

733
00:34:07,365 --> 00:34:10,340
మేము సరే చెప్పాలనుకోవడం, నేను + +.

734
00:34:10,340 --> 00:34:13,820
నేను = నేను + 1 మాట్లాడుతూ అదే విషయం.

735
00:34:13,820 --> 00:34:17,090
కానీ అది చాలా తరచుగా ఉపయోగించబడుతుంది, ఎందుకంటే సంక్షిప్తలిపి ఆ కేవలం ఉంది

736
00:34:17,090 --> 00:34:18,340
నేను చెప్పడం + +.

737
00:34:20,800 --> 00:34:22,050
>> గ్రేట్.

738
00:34:25,230 --> 00:34:26,400
సరే.

739
00:34:26,400 --> 00:34:29,210
ఇక్కడ నేను నిజంగా నా ఆపిల్ కార్యక్రమం నుండి బయటకు లేదు.

740
00:34:29,210 --> 00:34:33,070
కాబట్టి నేను కంట్రోల్-C మరియు ఆ వెంటనే క్లిక్ వెళుతున్న

741
00:34:33,070 --> 00:34:34,989
బూట్లు నా ప్రోగ్రామ్ నుండి నాకు మరియు తెస్తుంది

742
00:34:34,989 --> 00:34:35,920
నాకు టెర్మినల్ తిరిగి.

743
00:34:35,920 --> 00:34:38,320
కాబట్టి మీరు ఎక్కడ బగ్ లోకి అమలు చేస్తే, ఉదాహరణకు, ఆ

744
00:34:38,320 --> 00:34:40,750
మీ కాగా లూప్ అటువంటి ఉందని నవీకరించడానికి మర్చిపోయాను

745
00:34:40,750 --> 00:34:43,150
ముగించవచ్చు మరియు మీరు ఒక అనంతమైన లూప్ ఎంటర్, మీరు చేయగలరు

746
00:34:43,150 --> 00:34:46,400
ఆ బయటకు తీసుకురావాలంటే కంట్రోల్-C ఉపయోగించండి.

747
00:34:46,400 --> 00:34:46,639
అన్ని కుడి.

748
00:34:46,639 --> 00:34:47,960
కాబట్టి మేము డైరెక్టరీ ఉన్నారు.

749
00:34:47,960 --> 00:34:52,010
కాబట్టి యొక్క హలో తయారు చేద్దాము.

750
00:34:52,010 --> 00:35:01,710
మేము హలో అమలు చేస్తే ఆపై, మేము వీడ్కోలు లూప్ చేసే చూడండి

751
00:35:01,710 --> 00:35:03,350
మా కోసం లూప్ వంటి ఖచ్చితమైన విషయం చేస్తుంది.

752
00:35:03,350 --> 00:35:05,060
కాబట్టి ఇది ముందు సూచనను స్.

753
00:35:05,060 --> 00:35:06,980
మీరు మరింత ఉచ్చులు కోసం సౌకర్యవంతంగా లేదా చేస్తున్నా

754
00:35:06,980 --> 00:35:09,850
అయితే ఉచ్చులు వారు మార్చుకోగలిగిన ఉంటుంది.

755
00:35:09,850 --> 00:35:15,130
కావాల్సిన మీరు ద్వారా iterate చేయడానికి మీరు ఉపయోగించాలనుకుంటున్న ఒక కాబట్టి -

756
00:35:15,130 --> 00:35:16,020
ఈ సందర్భంలో -

757
00:35:16,020 --> 00:35:19,410
మారియో పిరమిడ్ యొక్క ఎత్తు.

758
00:35:19,410 --> 00:35:23,020
మీరు సున్నా వద్ద మొదలు ఉంటే మరలా, ఈ, ఒక రిమైండర్ ఉంది

759
00:35:23,020 --> 00:35:25,430
మీ వేరియబుల్ కోసం, మీరు ఒక వేరే చెయ్యవచ్చును

760
00:35:25,430 --> 00:35:27,360
మీరు ఒక ప్రారంభించబడింది కంటే పరిస్థితి.

761
00:35:27,360 --> 00:35:29,620
కాబట్టి ఈ పట్టిక యొక్క రకం మీరు ఒక రిమైండర్ చూపిస్తుంది.

762
00:35:29,620 --> 00:35:33,660
మీరు అప్పుడు, ఉదాహరణకు, 10 సార్లు పునరావృతం చేయాలనుకుంటే

763
00:35:33,660 --> 00:35:36,030
సున్నా వద్ద మీ వేరియబుల్ ప్రారంభించవచ్చు గాని.

764
00:35:36,030 --> 00:35:39,350
మరియు మీ పరిస్థితి 10 కంటే తక్కువ ఉంటుంది.

765
00:35:39,350 --> 00:35:43,020
కాబట్టి ఆ రకమైన మీరు ఆ యొక్క మాతృక చూపిస్తుంది.

766
00:35:43,020 --> 00:35:43,360
>> సరే.

767
00:35:43,360 --> 00:35:45,790
కాబట్టి మేము మారియో ద్వారా మారారు.

768
00:35:45,790 --> 00:35:48,820
మేము, సరే, మనము సరైన ఇన్పుట్ కోసం తనిఖీ చేయాలి, అన్నాడు చేసిన

769
00:35:48,820 --> 00:35:50,800
సున్నా మరియు 23 కలుపుకొని.

770
00:35:50,800 --> 00:35:53,370
మేము నమూనా యొక్క కొన్ని రకం మార్గం ఏదో కనుగొనేందుకు వెళుతున్న

771
00:35:53,370 --> 00:35:57,920
nth వరుస లేదా ith వరుస వ్యక్తం.

772
00:35:57,920 --> 00:36:01,560
మరియు మేము ఈ ముద్రణ చూడాలని ఉద్దేశ్యంతో, సరే, నిర్ణయించుకుంటారు చూడాలని

773
00:36:01,560 --> 00:36:04,870
అనేక ప్రదేశాలు, ఈ అనేక hashes, కొత్త లైన్.

774
00:36:04,870 --> 00:36:05,050
అన్ని కుడి.

775
00:36:05,050 --> 00:36:05,720
కాబట్టి మేము మా దగ్గర.

776
00:36:05,720 --> 00:36:08,570
కాబట్టి ఇప్పుడు మేము గ్రీడీ కు తరలించవచ్చు.

777
00:36:08,570 --> 00:36:14,500
గ్రీడీ ఒక యూజర్ మీరు ఒక మొత్తం యొక్క ఇస్తాడు ప్రోగ్రామ్

778
00:36:14,500 --> 00:36:17,460
ముఖ్యంగా క్యాషియర్ వంటి మీరు తిరిగి అవసరమైన నగదు.

779
00:36:17,460 --> 00:36:21,530
కానీ మీరు వీలైనంత తక్కువ నాణేలు ఉపయోగించాలనుకుంటున్నాను.

780
00:36:21,530 --> 00:36:25,070
ఒక గ్రీడీ అల్గోరిథం లో వస్తుంది పేరు మరియు ఈ ఉంది

781
00:36:25,070 --> 00:36:30,440
మేము సాధ్యమైనంత నాణేల కనీస మొత్తం ఉపయోగించే చెయ్యవచ్చును

782
00:36:30,440 --> 00:36:31,900
మార్పు ఆ మొత్తం చేయండి.

783
00:36:34,500 --> 00:36:34,990
>> సరే.

784
00:36:34,990 --> 00:36:40,480
మీ ద్రావణంలో ఈ ఒక ఉదాహరణ చూడండి ఉండవచ్చు కాబట్టి

785
00:36:40,480 --> 00:36:42,540
ఈ వంటివి.

786
00:36:42,540 --> 00:36:45,410
మీరు అమలు. / అత్యాశ.

787
00:36:45,410 --> 00:36:47,920
మీరు సరే చెప్పడానికి ప్రాంప్ట్ చేయబడతారు, అలాగే మార్పు ఎంత విషాదం ఉంది?

788
00:36:47,920 --> 00:36:50,780
ఆ విలువ డాలర్లలో ఒక విలువ అన్నారు.

789
00:36:50,780 --> 00:36:52,440
కాబట్టి ఒక ఫ్లోట్ చేస్తాడు.

790
00:36:52,440 --> 00:36:55,630
మీ ప్రోగ్రామ్ తరువాత కనీస మొత్తం లెక్కించేందుకు ఉంటుంది

791
00:36:55,630 --> 00:37:00,380
ఈ సందర్భంలో, $ 0.32 చేసేందుకు నాణేల.

792
00:37:00,380 --> 00:37:04,550
కాబట్టి కనీస నాలుగు ఉంది.

793
00:37:04,550 --> 00:37:07,480
నడక యొక్క మేము ఏమి చెయ్యాలో అంచనా ముందు, లెట్స్ రకమైన

794
00:37:07,480 --> 00:37:10,770
మీరు గురించి వెళ్ళవచ్చు ఆ ప్రక్రియ ద్వారా.

795
00:37:10,770 --> 00:37:16,480
ఇన్పుట్ 32 కాబట్టి, అప్పుడు తప్పనిసరిగా నేను ఉపయోగించే వెళుతున్న

796
00:37:16,480 --> 00:37:19,100
నేను చాలా ఉపయోగించడానికి ఉంటే నాణేల కనీసం మొత్తం

797
00:37:19,100 --> 00:37:20,460
వీలైనంత పెద్ద నాణేలు.

798
00:37:20,460 --> 00:37:20,870
కుడి?

799
00:37:20,870 --> 00:37:25,420
కనుక ఇది ఒక క్వార్టర్ ఉపయోగించడానికి చాలా సులభం

800
00:37:25,420 --> 00:37:27,070
ఐదు నికెల్స్ వ్యతిరేకంగా.

801
00:37:27,070 --> 00:37:31,740
చెప్పాలి కాబట్టి కదా, మీరు $ 0.32 తిరిగి అవసరం.

802
00:37:31,740 --> 00:37:36,660
Well, నేను ఈ ఒక క్వార్టర్ ఉపయోగించవచ్చు?

803
00:37:36,660 --> 00:37:37,480
అవును, మీరు చెయ్యగలరు.

804
00:37:37,480 --> 00:37:41,970
ఆపై మీరు $ 0.07 కు తగ్గింది ఉంటుంది.

805
00:37:41,970 --> 00:37:46,070
నేను మీరు తిరిగి చెల్లించే మరొక పావు ఉపయోగించవచ్చు ఉంటే యొక్క చూసేలా.

806
00:37:46,070 --> 00:37:46,870
లేదు, అదే.

807
00:37:46,870 --> 00:37:48,200
నేను ఆ ఒక క్వార్టర్ సరిపోవు.

808
00:37:48,200 --> 00:37:52,110
నేను తరువాత అతిపెద్ద నాణెం తరలించడానికి వెళుతున్న.

809
00:37:52,110 --> 00:37:53,250
నేను ఒక విలువ తక్కువైన ఉపయోగించవచ్చా?

810
00:37:53,250 --> 00:37:55,800
$ 0.07, మీరు $ 0.07 చెల్లించడానికి ఒక చవుకయైన ఉపయోగించలేరు.

811
00:37:55,800 --> 00:37:56,840
కాబట్టి మీరు ఏ చెబుతున్నారు.

812
00:37:56,840 --> 00:38:00,490
ఒక నికెల్ ఇది తదుపరి, తరలించు.

813
00:38:00,490 --> 00:38:01,440
మీరు ఒక పైసా ఉపయోగించవచ్చా?

814
00:38:01,440 --> 00:38:02,930
అవును.

815
00:38:02,930 --> 00:38:06,440
ఏడు $ 0.05 కంటే ఎక్కువగా ఉంది, కాబట్టి మేము ఒక నికెల్ ఉపయోగించవచ్చు.

816
00:38:06,440 --> 00:38:08,640
మరియు తర్వాత మేము ను రెండు సెంట్లు ఉంది.

817
00:38:08,640 --> 00:38:11,110
మేము ఒక పెన్నీ ఉపయోగించవచ్చా?

818
00:38:11,110 --> 00:38:12,180
అవును మేము.

819
00:38:12,180 --> 00:38:13,070
మేము మరొక పెన్నీ ఉపయోగించవచ్చా?

820
00:38:13,070 --> 00:38:13,380
అవును.

821
00:38:13,380 --> 00:38:14,710
మేము మరొక పెన్నీ ఉపయోగించవచ్చా?

822
00:38:14,710 --> 00:38:17,070
ఇప్పుడు మేము విజయవంతంగా లేవు ఎందుకంటే

823
00:38:17,070 --> 00:38:19,400
యూజర్ తిరిగి చెల్లించబడుతుంది.

824
00:38:19,400 --> 00:38:23,620
అందువలన, నాలుగు నాణేలు చేరింది.

825
00:38:23,620 --> 00:38:26,370
>> కాబట్టి మేము ప్రతి, ఆ ప్రక్రియ గురించి ఆలోచిస్తూ

826
00:38:26,370 --> 00:38:29,080
సమయం సరే నిర్ణయించుకుంటారు,

827
00:38:29,080 --> 00:38:31,050
మేము ఉపయోగించే అతిపెద్ద నాణెం ఏది?

828
00:38:31,050 --> 00:38:37,240
ఒకసారి మేము ఆ ఉపయోగించడానికి, మేము రకమైన ఎంత ఒక మానసిక గమనిక ఉంచడానికి

829
00:38:37,240 --> 00:38:39,650
మేము మరియు యూజర్ తిరిగి అవసరం మరింత డబ్బు ఎన్ని

830
00:38:39,650 --> 00:38:41,310
నాణేలు మేము ఉపయోగిస్తున్నాము.

831
00:38:44,640 --> 00:38:45,200
సరే.

832
00:38:45,200 --> 00:38:48,930
అయితే మళ్ళీ, మొదటి మెట్టు - కేవలం మారియో వంటి - ప్రాంప్ట్ ఉంది

833
00:38:48,930 --> 00:38:51,120
ఒక ద్రవ్య మొత్తం యూజర్.

834
00:38:51,120 --> 00:38:53,920
కాబట్టి ఈ మొత్తం ఉండబోతుంది -

835
00:38:53,920 --> 00:38:56,040
మేము వెళుతున్నాం ఎందుకంటే అది ఒక సౌకర్యం విలువ కలిగి జరగబోతోంది

836
00:38:56,040 --> 00:38:57,310
డాలర్ల వారిని అడగండి.

837
00:38:57,310 --> 00:39:00,550
కాబట్టి ఆ డేటా రకం పూర్ణాంకం మాత్రం లేదు.

838
00:39:00,550 --> 00:39:01,860
కానీ ఒక చేస్తాడు -

839
00:39:04,960 --> 00:39:07,700
అవును, ఫ్లోట్.

840
00:39:07,700 --> 00:39:10,780
కానీ ఆపిల్ వంటి తేలియాడుతున్న అనుకూల లేదా ప్రతికూల ఉంటుంది.

841
00:39:10,780 --> 00:39:13,390
కాబట్టి మీరు విలువలు తనిఖీ చేసినప్పుడు, మీకు కావలసిన చూడాలని

842
00:39:13,390 --> 00:39:15,380
మీ ఫ్లోట్ నిర్ధారించడానికి -

843
00:39:15,380 --> 00:39:19,710
వినియోగదారు ఇన్పుట్ను - కాని ప్రతికూలంగా ఉంటుంది.

844
00:39:19,710 --> 00:39:20,960
సరే.

845
00:39:22,630 --> 00:39:26,720
మేము మా మొత్తం కార్యక్రమం ఏర్పాటైన వ్యవహరించే కాలేదు, సూచిస్తాయి

846
00:39:26,720 --> 00:39:31,610
0.25 ద్వారా వంతులు, et సెటేరా 0.1, ద్వారా ఆఫ్ డైమ్స్.

847
00:39:31,610 --> 00:39:36,280
కానీ నేను స్వచ్ఛమైన సెంట్లు వ్యవహారాల గురించి అది చాలా సులభంగా కనుగొనేందుకు.

848
00:39:36,280 --> 00:39:36,910
కూడా -

849
00:39:36,910 --> 00:39:39,370
మరియు మేము ఒక బిట్ తర్వాత ఈ గురించి మాట్లాడదాము -

850
00:39:39,370 --> 00:39:43,610
సి లో, ఫ్లోటింగ్ పాయింట్లు imprecision అని ఏదో ఉంది.

851
00:39:43,610 --> 00:39:48,660
కాబట్టి మీరు ఉదాహరణకు, 0.12 లో నమోదు చేసినప్పుడు, కంప్యూటర్

852
00:39:48,660 --> 00:39:53,010
వాస్తవానికి 0.1111119 వంటి దుకాణాలు లేదా

853
00:39:53,010 --> 00:39:54,350
అలాంటిదే.

854
00:39:54,350 --> 00:39:56,900
>> కనుక ఇది సెంట్లు మార్చుకునేందుకు చాలా సులభం.

855
00:39:56,900 --> 00:40:02,190
కాబట్టి మేము ఎలా సెంట్లు ఒక డాలర్ విలువ మార్చేందుకు చెయ్యాలి?

856
00:40:02,190 --> 00:40:03,540
SPEAKER 5: 100 టైమ్స్ అది?

857
00:40:03,540 --> 00:40:03,920
ZAMYLA చాన్: అవును.

858
00:40:03,920 --> 00:40:04,110
అవును.

859
00:40:04,110 --> 00:40:07,110
కాబట్టి మేము 100 ద్వారా సార్లు అది చేస్తాను.

860
00:40:07,110 --> 00:40:10,820
కానీ తేలియాడుతూ పాయింట్లు గురించి ఒక గమ్మత్తైన విషయం అని అక్కడ

861
00:40:10,820 --> 00:40:11,790
కొన్ని imprecision ఉంది.

862
00:40:11,790 --> 00:40:16,090
కాబట్టి యొక్క ఆ యొక్క ఒక ఉదాహరణ చూద్దాం.

863
00:40:18,760 --> 00:40:21,360
నేను imprecision.c తెరిచి వెళుతున్న.

864
00:40:21,360 --> 00:40:23,690
సరే.

865
00:40:23,690 --> 00:40:24,860
ఈ చాలా సులభమైన కార్యక్రమం.

866
00:40:24,860 --> 00:40:26,970
ఇది ఒక ఫ్లోట్ అడుగుతాడు, మరియు అది తిరిగి ముద్రిస్తుంది.

867
00:40:35,950 --> 00:40:39,600
టెర్మినల్ లో ఒక nice చిట్కా మీరు స్పష్టమైన టైప్ చెయ్యవచ్చు, మరియు

868
00:40:39,600 --> 00:40:41,180
అప్పుడు మీరు స్పష్టమైన తెర కలిగి.

869
00:40:41,180 --> 00:40:45,270
మరియు మీరు ఏ మునుపటి అవుట్పుట్ లేదా ఏ కు లేదు

870
00:40:45,270 --> 00:40:47,490
లోపాలు లేదా బగ్ నివేదికలు, అలాంటిదే.

871
00:40:47,490 --> 00:40:48,120
సరే.

872
00:40:48,120 --> 00:40:49,675
కాబట్టి యొక్క imprecision తయారు చేద్దాము.

873
00:40:53,250 --> 00:40:56,250
యొక్క అమలు లెట్.

874
00:40:56,250 --> 00:40:57,890
నేను haven't -

875
00:40:57,890 --> 00:41:03,830
నా కోడ్ లో, నాకు అది ఇష్టం ఏ ప్రాంప్ట్ లేదా ఏదైనా ప్రింట్ లేదు.

876
00:41:03,830 --> 00:41:05,010
కాబట్టి అది కేవలం ఒక మెరిసే కర్సర్ ఉంది.

877
00:41:05,010 --> 00:41:07,390
కాబట్టి అది నాకు ఇన్పుట్ ఫ్లోట్ వరకు వేచి యొక్క.

878
00:41:07,390 --> 00:41:08,640
కాబట్టి let's -

879
00:41:10,610 --> 00:41:11,280
ఒక యాదృచ్చిక ఫ్లోట్.

880
00:41:11,280 --> 00:41:15,080
మరియు మీరు దానిని తిరిగి ముద్రిస్తుంది కాని కొన్ని అదనపు కలిగి చూడండి

881
00:41:15,080 --> 00:41:18,180
మేము ఖచ్చితంగా లేదు ఆ సంఖ్యలు.

882
00:41:18,180 --> 00:41:21,980
కాబట్టి మేము కాదు ఆ నిర్ధారించుకోవాలి

883
00:41:21,980 --> 00:41:23,300
మా కార్యక్రమం జరిగే.

884
00:41:23,300 --> 00:41:27,550
>> కాబట్టి అప్పుడు మేము మీరు ఏమి ఖచ్చితంగా మేము నిజంగా తయారు ఉంది

885
00:41:27,550 --> 00:41:31,300
రకమైన తగిన విలువ ఆఫ్ గుండ్రంగా.

886
00:41:31,300 --> 00:41:31,850
కుడి?

887
00:41:31,850 --> 00:41:37,820
కాబట్టి అదృష్టవశాత్తూ, మేము రౌండ్ ఉన్నాయి అనే చర్య

888
00:41:37,820 --> 00:41:38,550
పరికరంలోని.

889
00:41:38,550 --> 00:41:41,390
ఇది గణిత లైబ్రరీ ఉంది.

890
00:41:41,390 --> 00:41:44,710
మీరు రౌండ్ ఎలా ఉపయోగించాలో తెలుసుకోవాలంటే, మీరు నిజంగా ఉపయోగించడానికి

891
00:41:44,710 --> 00:41:45,220
మాన్యువల్.

892
00:41:45,220 --> 00:41:48,160
మీరు మనిషి రౌండ్ క్లిక్ చేయవచ్చు.

893
00:41:48,160 --> 00:41:51,190
ఇక్కడ దానిని గుర్తు -

894
00:41:51,190 --> 00:41:53,220
చివరికి అర్థాన్ని విడదీసేందుకు కొద్దిగా కష్టం, కానీ ఉండవచ్చు

895
00:41:53,220 --> 00:41:54,690
మీరు దాని హ్యాంగ్ పొందుతారు.

896
00:41:54,690 --> 00:42:00,060
ఇది రకం కొన్ని అప్పుడు ఫంక్షన్ దేనిని చూపుతుంది మరియు

897
00:42:00,060 --> 00:42:01,790
ఆ సాధ్యమయ్యే ఉపయోగాలు.

898
00:42:01,790 --> 00:42:10,210
మీరు చివరకు నుండి సరైన, చెల్లుబాటు అయ్యే ఇన్పుట్ పొందండి, అప్పుడు

899
00:42:10,210 --> 00:42:14,490
యూజర్, అప్పుడు మీరు సెంట్లు మార్చవచ్చు మీరు.

900
00:42:14,490 --> 00:42:18,530
మీరు ఈ నివారించడానికి తద్వారా మీరు విలువ చుట్టూ నిర్ధారించుకోండి

901
00:42:18,530 --> 00:42:21,780
పాయింట్ imprecision తేలియాడే.

902
00:42:21,780 --> 00:42:22,340
>> సరే.

903
00:42:22,340 --> 00:42:26,190
కాబట్టి మేము ఒక ద్రవ్య మొత్తం యూజర్ ప్రాంప్ట్ చేసిన.

904
00:42:26,190 --> 00:42:31,460
ఇప్పుడు మేము మీరు ఏమి ముఖ్యంగా కుడి, తనిఖీ ఉంది?

905
00:42:31,460 --> 00:42:35,500
సరే, నేను సాధ్యం అతిపెద్ద నాణెం ఉపయోగించవచ్చు?

906
00:42:35,500 --> 00:42:37,040
మీరు, అప్పుడు మీరు దాన్ని ఉపయోగించండి.

907
00:42:37,040 --> 00:42:40,250
మీరు ఇప్పటివరకు ఉపయోగించి ఎన్ని నాణేలు ట్రాక్ మరియు

908
00:42:40,250 --> 00:42:41,710
కూడా తగ్గుముఖం మొత్తం.

909
00:42:41,710 --> 00:42:42,240
కుడి?

910
00:42:42,240 --> 00:42:44,880
ఆపై మీరు తనిఖీ చూడాలని.

911
00:42:44,880 --> 00:42:47,940
ఒకసారి మీరు వంతులు అయిపోయిన రకం, మీరు వెళ్లాలనుకుంటే

912
00:42:47,940 --> 00:42:49,545
తదుపరి సాధ్యం విషయాల.

913
00:42:49,545 --> 00:42:59,380
>> లూప్ యొక్క కాబట్టి ఏ విధమైన నిర్మాణం లేదా ఏ రకమైన మేము వాటిని

914
00:42:59,380 --> 00:43:03,850
నిరంతరం మేము ఇప్పటికీ ఉపయోగించవచ్చు లేదో తనిఖీ చేయడానికి మీరు ఉపయోగించాలనుకుంటున్న

915
00:43:03,850 --> 00:43:05,100
ఒక క్వార్టర్, ఉదాహరణకు?

916
00:43:07,380 --> 00:43:09,280
SPEAKER 6: కంటే ఎక్కువ ఉన్నప్పుడు విలువ?

917
00:43:09,280 --> 00:43:10,150
ZAMYLA చాన్: అవును, సంపూర్ణ.

918
00:43:10,150 --> 00:43:10,590
సరిగ్గా.

919
00:43:10,590 --> 00:43:12,630
కాబట్టి విలువ కంటే ఎక్కువగా ఉంటుంది.

920
00:43:12,630 --> 00:43:16,300
కాబట్టి మేము తిరిగి ఇవ్వడానికి కలిగి విలువ ఇప్పటికీ ఉంది

921
00:43:16,300 --> 00:43:19,410
మేము ఇంకా ఒక క్వార్టర్ ఉపయోగించవచ్చు, అయితే, ఒక క్వార్టర్ కంటే పెద్ద,

922
00:43:19,410 --> 00:43:20,490
వంతులు ఉపయోగించండి.

923
00:43:20,490 --> 00:43:21,450
ఆ ట్రాక్.

924
00:43:21,450 --> 00:43:22,610
మరియు తర్వాత వెళ్ళాలని ఉంచండి.

925
00:43:22,610 --> 00:43:25,040
పర్ఫెక్ట్.

926
00:43:25,040 --> 00:43:26,290
సరే.

927
00:43:28,190 --> 00:43:32,580
ఓహ్, ఇక్కడ నేను ప్రింట్ ఎలా కొన్ని చిట్కాలు చేర్చాను

928
00:43:32,580 --> 00:43:33,830
అవుట్ విలువలు.

929
00:43:36,330 --> 00:43:38,810
మీ printf ఫంక్షన్ లో, మేము సాధారణంగా ఉన్నాను కేవలం

930
00:43:38,810 --> 00:43:39,760
తీగలను వ్యవహరిస్తుంది.

931
00:43:39,760 --> 00:43:43,290
కానీ మీరు ఒక పూర్ణాంకానికి లేదా ఏ రకమైన ముద్రించాలా ఉంటుంది

932
00:43:43,290 --> 00:43:46,510
అంకెల, మీరు స్థానంలో ఉన్నవారు ఒక రకమైన వ్రాయండి రకం ఉంటుంది.

933
00:43:46,510 --> 00:43:50,840
కాబట్టి ఆ పూర్ణ సంఖ్యలు శాతం,% d ద్వారా ప్రాతినిధ్యం ఉంది.

934
00:43:50,840 --> 00:43:53,780
మీరు తర్వాత మీరు నిజంగా చేస్తాము తర్వాత, రాయడానికి మీరు -

935
00:43:53,780 --> 00:43:54,900
కామాతో తర్వాత -

936
00:43:54,900 --> 00:43:57,990
వాస్తవానికి అక్కడ జరిగే క్రియల విలువ ప్రవేశపెట్టింది.

937
00:43:57,990 --> 00:43:58,510
కుడి.

938
00:43:58,510 --> 00:43:58,840
>> సరే.

939
00:43:58,840 --> 00:44:02,050
కనుక మేము లేదో తనిఖీ కావలసిన కనుగొన్నాము -

940
00:44:02,050 --> 00:44:04,950
ఇలా ఒక మార్గం నిరంతరం తనిఖీ అనే

941
00:44:04,950 --> 00:44:08,640
మేము ఇంకా ఉంచడానికి, వంతులు ఉపయోగించడానికి అప్పుడు వంతులు ఉపయోగించడానికి, మరియు చేయవచ్చు

942
00:44:08,640 --> 00:44:11,460
ట్రాక్, తరువాత అతిపెద్ద విలువ కొనసాగండి.

943
00:44:11,460 --> 00:44:15,010
ఇప్పుడు మీరు ఈ చేయగల చక్కగా మార్గం యొక్క మరొక రకం

944
00:44:15,010 --> 00:44:16,770
ఆపరేటర్లు మాడ్యులో ఉపయోగించి.

945
00:44:16,770 --> 00:44:22,710
కాబట్టి మేము ఇప్పటికే ప్లస్, మైనస్, గుణకారం, మరియు విభజన కలిగి

946
00:44:22,710 --> 00:44:23,560
మాకు అందుబాటులో.

947
00:44:23,560 --> 00:44:25,600
కానీ మాడ్యులో ఆపరేటర్లు చక్కగా యొక్క రకం.

948
00:44:25,600 --> 00:44:28,630
ఇది ఏమి చేస్తుంది ఇది నిజానికి మీరు మిగిలిన తిరిగి

949
00:44:28,630 --> 00:44:31,750
రెండు సంఖ్యల విభజన.

950
00:44:31,750 --> 00:44:34,680
మీరు పొడవైన విభాజక లో గుర్తు చేసుకుంటూ ఉంటే మీరు ఎప్పుడు, సే,

951
00:44:34,680 --> 00:44:40,100
3 ద్వారా విభజించబడింది 74, మీరు ఇది రాస్తుంది, కలిగి

952
00:44:40,100 --> 00:44:43,260
వ్యవకలనం, ఆపై చివరిలో దిగువన సంఖ్య

953
00:44:43,260 --> 00:44:44,050
మిగిలిన.

954
00:44:44,050 --> 00:44:47,120
Well, మాడ్యులో ఏమి ఇది నిజానికి మీరు ఆ ఇస్తుంది.

955
00:44:47,120 --> 00:44:51,290
74 కాబట్టి మాడ్యులో 3 మీరు 2 ఇస్తుంది.

956
00:44:51,290 --> 00:44:56,310
ఏ ఉండదు అదేవిధంగా, 10 మోడ్యులో 2 మీరు 0 ఇస్తుంది

957
00:44:56,310 --> 00:44:59,340
మిగిలిన మీరు 2 10 విభజించబడినప్పుడు.

958
00:44:59,340 --> 00:45:03,940
6 మాడ్యులో 5, అలాగే 5 అప్పుడు 6 సార్లు ఒక వెళతాడు మరియు

959
00:45:03,940 --> 00:45:05,900
అది 1 ను చేసింది.

960
00:45:05,900 --> 00:45:09,930
మీరు 7 మాడ్యులో 9 ఉంటే అప్పుడు, అలాగే 9 7 కంటే పెద్దగా ఉంది.

961
00:45:09,930 --> 00:45:11,830
అది ఏ ఇతర సార్లు వెళ్ళి కాదు.

962
00:45:11,830 --> 00:45:15,560
కాబట్టి అది తిరిగి విలువ 7 భావన కల్పిస్తుంది.

963
00:45:15,560 --> 00:45:21,590
మీరు మాడ్యులో గురించి అనుకుంటే కాబట్టి, ఎలా మీరు మిగిలిన ఇస్తుంది

964
00:45:21,590 --> 00:45:25,170
మీరు ఏదో తిరగడానికి తర్వాత, మీరు చూడండి రకం ఎలా మీరు

965
00:45:25,170 --> 00:45:27,490
అత్యాశ, కుడి ఉపయోగించండి చేయగలరు?

966
00:45:30,340 --> 00:45:34,170
మీరు రకమైన విభజన బహుశా మాడ్యులో మిళితం చేసుకుంటూ ఉంటే

967
00:45:34,170 --> 00:45:36,410
ఆపరేటర్లు, అలాంటిదే, అప్పుడు మీరు ఒక చల్లని ఉండవచ్చు

968
00:45:36,410 --> 00:45:38,870
సమస్య సెట్ చేరుకోవటానికి mathy మార్గం యొక్క రకాన్ని.

969
00:45:44,010 --> 00:45:46,090
>> కాబట్టి ఇప్పుడు మేము వివిధ ఒక జంట అక్కడ తెలిసిన

970
00:45:46,090 --> 00:45:48,350
మేము ఈ చేయగల మార్గాలను - చాలా ఖచ్చితంగా ఉన్నాయి

971
00:45:48,350 --> 00:45:54,160
వివిధ మార్గాల్లో కూడా ఉచ్చులు రాయడానికి.

972
00:45:54,160 --> 00:45:57,020
నేను ఇక్కడ కొన్ని pseudocode వ్రాయలేదు.

973
00:45:57,020 --> 00:46:01,760
మీ యొక్క అస్థిపంజరం రకం సమానంగా కాదు

974
00:46:01,760 --> 00:46:02,460
మీరు వ్రాసే కోడ్.

975
00:46:02,460 --> 00:46:05,580
కానీ ముఖ్యంగా, ఆలోచనా ప్రక్రియ మరియు మార్గం

976
00:46:05,580 --> 00:46:06,940
మేము చర్చించారు కేవలం.

977
00:46:06,940 --> 00:46:10,310
కాబట్టి మొదటి, మొదటి పంక్తి కొంత పొందడానికి అని

978
00:46:10,310 --> 00:46:12,490
డాలర్లలో.

979
00:46:12,490 --> 00:46:16,960
ఆపై అవ్యక్త సెంట్లు దానిని అక్కడ convert ఉంది.

980
00:46:16,960 --> 00:46:20,540
వంతులు ఉపయోగించబడుతుంది అప్పుడు, మేము మీరు

981
00:46:20,540 --> 00:46:21,750
COUNT పెంచుతాయి.

982
00:46:21,750 --> 00:46:24,360
మరియు తర్వాత మేము మొత్తం, విలువ ఆ తగ్గించడానికి కావలసిన

983
00:46:24,360 --> 00:46:25,300
మేము తిరిగి తిరిగి చేస్తున్నారు.

984
00:46:25,300 --> 00:46:28,170
మీరు ఇక్కడ చూడండి, అది చాలా C. కానీ నేను కూడా మీరు

985
00:46:28,170 --> 00:46:31,550
విషయాలు ఇండెంట్, నేను లోపల నా పరిస్థితులు ఉంచండి

986
00:46:31,550 --> 00:46:32,190
కుండలీకరణాలు.

987
00:46:32,190 --> 00:46:34,370
>> కాబట్టి అప్పుడు ఆ రకమైన నాకు ప్రారంభించారు పొందుతాడు.

988
00:46:34,370 --> 00:46:36,620
మరియు తరువాత, నేను సింటాక్స్ అప్ చూడవచ్చు.

989
00:46:36,620 --> 00:46:40,230
తరచుగా ఒక సమస్య గురించి నిజంగా కష్టతరమైన భాగంగా ఉంది

990
00:46:40,230 --> 00:46:41,860
మీరు చెయ్యవలసింది సరిగ్గా తెలుసుకోండి.

991
00:46:41,860 --> 00:46:44,610
కాబట్టి మీరు డౌన్ రాయడానికి, అప్పుడు అది చాలా సులభం

992
00:46:44,610 --> 00:46:45,810
pseudocode అనువదించు.

993
00:46:45,810 --> 00:46:49,340
ఆపై pseudocode నుండి, వాక్యనిర్మాణం చాలా సులభం వస్తుంది.

994
00:46:49,340 --> 00:46:52,140
కాబట్టి మేము, కౌంట్ పెరుగుతుంది, వంతులు, ఉపయోగించబడుతుంది చూడండి

995
00:46:52,140 --> 00:46:53,220
తగ్గుతుంది.

996
00:46:53,220 --> 00:46:57,310
ఆఫ్ డైమ్స్ ఉపయోగించబడుతుంది, అప్పుడు మీరు కనుక అది నిర్వహించడం మరియు అందువలన

997
00:46:57,310 --> 00:47:00,670
ముందుకు, వరకు మీరు మీ నాణేలు అన్ని అయిపోయిన చేశారు.

998
00:47:00,670 --> 00:47:03,410
మీరు ఉంటుంది ఉపయోగించబడుతుంది నాణేల సంఖ్య, అవ్ట్ ప్రింట్

999
00:47:03,410 --> 00:47:06,620
యూజర్ చేయడానికి కనీస మొత్తం విలువ ఇన్పుట్.

1000
00:47:06,620 --> 00:47:09,370
మరియు అక్కడ మీరు మీ గ్రీడీ అల్గోరిథం ఉన్నాయి.

1001
00:47:09,370 --> 00:47:13,960
మీరు ఆ పూర్తి ఒకసారి మరియు అప్పుడు, మీరు కూడా pset 0 ముగిసింది.

1002
00:47:13,960 --> 00:47:16,155
>> ఎవరైనా ఏదైనా గురించి ఏవైనా ప్రశ్నలు ఉందా?

1003
00:47:19,420 --> 00:47:19,780
అన్ని కుడి.

1004
00:47:19,780 --> 00:47:22,900
Well, నేను మీరు కలిగి ఉంటే తర్వాత కొద్దిగా కోసం చుట్టూ అంటుకుంటుంది

1005
00:47:22,900 --> 00:47:23,970
ఏ ప్రశ్నలు.

1006
00:47:23,970 --> 00:47:24,940
ఈ walkthrough 1 ఉంది.

1007
00:47:24,940 --> 00:47:26,190
ధన్యవాదాలు.