1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:01,960
SPEAKER 1: యొక్క నీటి గురించి చర్చిద్దాం.

3
00:00:01,960 --> 00:00:07,280
ఈ సమస్య, మేము చెప్పడం అవ్వమని
మాకు నిమిషాల్లో ఎంతకాలం వారి షవర్ ఉంది

4
00:00:07,280 --> 00:00:11,040
ఆపై మేము సమానం లెక్కించేందుకు
నీటి సీసాల సంఖ్య

5
00:00:11,040 --> 00:00:12,970
వారి షవర్ ఉపయోగించారు.

6
00:00:12,970 --> 00:00:16,379
>> సో వాట్ మా చేయవలసిన యొక్క ఉన్నాయి
ఈ సమస్య కోసం?

7
00:00:16,379 --> 00:00:20,050
మొదటి, మేము చూడాలని
ప్రాంప్ట్ ఆపై ధ్రువీకరించడానికి

8
00:00:20,050 --> 00:00:22,100
యూజర్ మాకు ఇచ్చే ఇన్పుట్.

9
00:00:22,100 --> 00:00:24,790
ఒకసారి ఇది మాకు మేము హామీ
చెల్లుబాటు అయ్యే వినియోగదారు ఇన్పుట్,

10
00:00:24,790 --> 00:00:28,230
మేము లెక్కించేందుకు చూడాలని
నీటి సీసాలు సమానం సంఖ్య

11
00:00:28,230 --> 00:00:30,770
యూజర్ సమయంలో ఉందని
వారి షవర్, ఆపై మేము ఉన్నాము

12
00:00:30,770 --> 00:00:33,720
ద్వారా వాటిని మీరెప్పుడూ
ఆ సంఖ్యను ముద్రించిన.

13
00:00:33,720 --> 00:00:37,230
>> కాబట్టి యొక్క మా మొదటి పరిష్కరించడానికి వీలు
పని ప్రోత్సహించాడు మరియు నిర్ధారించడంలో

14
00:00:37,230 --> 00:00:38,550
యూజర్ ఇన్పుట్.

15
00:00:38,550 --> 00:00:40,910
ఈ కోసం మేము రాసిన
మీరు అని ఫంక్షన్

16
00:00:40,910 --> 00:00:43,950
CS50 లైబ్రరీ లో ఉన్న get_int.

17
00:00:43,950 --> 00:00:48,710
get_int ఆ యూజర్ ఇన్పుట్లను నిర్ధారిస్తుంది
పూర్ణాంకం, ఏ అనుకూల సంఖ్యలు కాబట్టి,

18
00:00:48,710 --> 00:00:51,700
వ్యతిరేక నంబర్లు, లేదా
సున్నా అన్ని అనుమతించబడతాయి.

19
00:00:51,700 --> 00:00:55,900
కానీ వినియోగదారు ఏదైనా ఇన్పుట్లను,
కాబట్టి అక్షరాలు లేదా సంఖ్యల ఏ కలయిక

20
00:00:55,900 --> 00:00:59,710
లేదా దశాంశ సంఖ్యలు, అప్పుడు
యూజర్ తిరిగి ప్రయత్నించమని అడుగబడును

21
00:00:59,710 --> 00:01:04,319
మరియు ఫంక్షన్ ఏదైనా అంగీకరించము
వినియోగదారు వాటిని పూర్ణాంకం ఇస్తుంది వరకు.

22
00:01:04,319 --> 00:01:06,410
>> కాబట్టి మేము ఎలా get_int ఉపయోగించగలను?

23
00:01:06,410 --> 00:01:10,830
మీరు మీ కార్యస్థలం తెరిస్తే మరియు
integer.c చేసుకుందాం అనే ఫైల్ సృష్టించడానికి

24
00:01:10,830 --> 00:01:12,110
కింది టైప్ చేయండి.

25
00:01:12,110 --> 00:01:14,760
హాష్ ట్యాగ్ cs50.h. ఉన్నాయి

26
00:01:14,760 --> 00:01:18,480
ఈ get_int ఎందుకంటే అవసరం
ఒక CS50 లైబ్రరీ ఫంక్షన్,

27
00:01:18,480 --> 00:01:21,890
కాబట్టి మేము ఉన్నాయి హాష్ ట్యాగ్ ఉండాలి
క్రమంలో దాని ప్రకటనను

28
00:01:21,890 --> 00:01:23,370
ఫంక్షన్ ఉపయోగించడానికి.

29
00:01:23,370 --> 00:01:26,570
అప్పుడు నా ప్రధాన
నేను వెళుతున్నాను పని

30
00:01:26,570 --> 00:01:29,560
కేవలం ఫంక్షన్ get_int కాల్.

31
00:01:29,560 --> 00:01:31,750
>> కాబట్టి యొక్క ఈ అమలు అనుమతిస్తాయి మరియు అది ఎలా పని చేస్తుందో చూడండి.

32
00:01:31,750 --> 00:01:35,092
నేను ఇప్పటికే అది సంకలనం చేసిన, కాబట్టి లెట్స్
కేవలం ముందుకు వెళ్లి ఈ కార్యక్రమం అమలు,

33
00:01:35,092 --> 00:01:36,480
./పూర్ణ సంఖ్య.

34
00:01:36,480 --> 00:01:39,880
ఇక్కడ నేను ఒక ప్రాంప్ట్ మరియు
ఇక్కడ నేను ఇన్పుట్ పేరు విలువ.

35
00:01:39,880 --> 00:01:44,880
నేను కొన్ని పూర్ణాంక చాలు సే,
50, కార్యక్రమం excepts వదిలేసి

36
00:01:44,880 --> 00:01:45,960
మరియు ఆ ఆ.

37
00:01:45,960 --> 00:01:49,350
>> కానీ నేను దాన్ని మళ్ళీ రన్ మరియు చెప్పినప్పుడు
వేరే నేను ఇన్పుట్ ఏదో.

38
00:01:49,350 --> 00:01:51,350
బహుశా ప్రపంచ హలో.

39
00:01:51,350 --> 00:01:55,660
కాబట్టి పూర్ణాంకం కాదు
ప్రోగ్రామ్ నాకు తిరిగి ప్రయత్నించమని అడుగుతుంది.

40
00:01:55,660 --> 00:01:59,160
యొక్క మళ్లీ ప్రయత్నించండి లెట్
బహుశా ఈ సమయంలో దశాంశ.

41
00:01:59,160 --> 00:02:03,450
0.5, మళ్ళీ, పూర్ణాంక కాబట్టి
కార్యక్రమం అంగీకరించము

42
00:02:03,450 --> 00:02:05,290
మరియు అది నాకు మళ్ళీ చెప్పండి చేస్తాము.

43
00:02:05,290 --> 00:02:07,070
కాబట్టి యొక్క మరొక సంఖ్య ఇస్తాను.

44
00:02:07,070 --> 00:02:09,830
కార్యక్రమం ఇది అంగీకరిస్తుంది,
వదిలేసి, మరియు మేము పూర్తి చేసిన.

45
00:02:09,830 --> 00:02:13,520
>> కాబట్టి ఇప్పుడు మేము ఒక ఫంక్షన్ కలిగి
మాకు మరియు నిర్ధారిస్తుంది అనుమతిస్తుంది

46
00:02:13,520 --> 00:02:16,790
యూజర్ ఇన్పుట్లను ఆ
పూర్ణాంక, కానీ మేము ఎలా

47
00:02:16,790 --> 00:02:20,330
నిజానికి ట్రాక్
పూర్ణాంక యూజర్ ద్వారా ఇన్పుట్?

48
00:02:20,330 --> 00:02:25,260
బాగా, మేము చేస్తాము అన్ని స్టోర్ ఉంది
ఒక కారకం ఈ విలువ, n చెప్పటానికే.

49
00:02:25,260 --> 00:02:30,580
సో నేను ఒక పూర్ణాంకం n డిక్లేర్ ఉంటే,
మరియు నేను get_int ఆ విలువ సెట్

50
00:02:30,580 --> 00:02:34,700
ఆపై n ఆపై నిల్వ చేస్తుంది సంసార
యూజర్ ఇన్పుట్ విలువ.

51
00:02:34,700 --> 00:02:38,620
>> అన్ని కుడి, కాబట్టి ఇప్పుడు మేము అని నిర్ధారిస్తుంది చేసిన
యూజర్ మాకు పూర్ణాంకం ఇస్తుంది

52
00:02:38,620 --> 00:02:42,550
మరియు మేము ట్రాక్ ఎలా తెలుసు
పూర్ణాంక, కానీ గుర్తుంచుకోవాలి,

53
00:02:42,550 --> 00:02:45,610
పూర్ణాంకాల అనుకూల మరియు ప్రతికూల స్పందనలు రెండూ ఉంటాయి.

54
00:02:45,610 --> 00:02:49,110
కనుక ఇది నిజంగా సమంజసం అనిపించుకోదు
ఈ సమస్య యొక్క సందర్భం లో

55
00:02:49,110 --> 00:02:53,570
వినియోగదారు ఒక షవర్ పడుతుంది ఆ
యొక్క ప్రతికూల 12 నిమిషాల చెబుతాను.

56
00:02:53,570 --> 00:02:59,310
కాబట్టి మేము వినియోగదారు నిర్ధారించుకోండి అవసరం
వాస్తవానికి మాకు ఒక సానుకూల పూర్ణాంక ఇస్తుంది.

57
00:02:59,310 --> 00:03:02,130
ఇప్పుడు మేము కేవలం లేదు
ఆ కోసం ఒకే ఫంక్షన్,

58
00:03:02,130 --> 00:03:04,620
కాబట్టి మేము చూడాలని
మమ్మల్ని ఆ సృష్టించడానికి.

59
00:03:04,620 --> 00:03:07,190
>> కాబట్టి మేము నిరంతరంగా కావలసిన
వినియోగదారును ప్రాంప్ట్

60
00:03:07,190 --> 00:03:09,730
వారు మాకు సానుకూల పూర్ణాంక ఇవ్వాలని వరకు.

61
00:03:09,730 --> 00:03:14,300
నేను నిరంతరం ఏదో చేస్తున్నదాన్ని ఉంటే
ఒక లూప్, ఒక పునరావృతం వంటిదని ఉంది.

62
00:03:14,300 --> 00:03:19,130
మేము ఉపయోగించే నిర్మాణాలు ఒకటి కాబట్టి
సి లో పునరావృతం మరియు ఉచ్చులు అమలు

63
00:03:19,130 --> 00:03:20,410
కాసేపు లూప్ ఉంది.

64
00:03:20,410 --> 00:03:23,020
సో ఒక సమయంలో లూప్, వంటి
ఇక్కడ చూపిన నిర్వర్తిస్తుంది

65
00:03:23,020 --> 00:03:27,030
సంసార లూప్ యొక్క శరీరం లో ఉంది
నిర్దిష్ట పరిస్థితి వేసుకునే అంచనాలు కాలం

66
00:03:27,030 --> 00:03:27,900
సత్యంకు.

67
00:03:27,900 --> 00:03:30,640
వెంటనే ఆ షరతు
అప్పుడు, తప్పుకు మదింపు

68
00:03:30,640 --> 00:03:34,830
కార్యక్రమం ముందుకు చేస్తుంది సంసార
లూప్ యొక్క శరీరం తర్వాత వస్తుంది.

69
00:03:34,830 --> 00:03:39,400
>> ఉచ్చులు వెళ్తున్నారు అందువలన
CS50 లో నిజంగా ఉపయోగకరంగా ఉంటుంది.

70
00:03:39,400 --> 00:03:42,590
కానీ ఈ ముఖ్యంగా
కేసు, మేము ఉన్నాము తెలుసు

71
00:03:42,590 --> 00:03:48,140
కనీసం వినియోగదారును ప్రాంప్ట్ అన్నారు
ఒకసారి మరియు అప్పుడు మాత్రమే లూప్ అవసరమైతే.

72
00:03:48,140 --> 00:03:51,080
కాబట్టి ఇక్కడ ఒక వచ్చారు
ప్రత్యేక నిర్మాణం మరియు ఆ

73
00:03:51,080 --> 00:03:55,020
అయితే చాలా పోలి
లూప్ ఒక డో-సమయంలో లూప్ అని.

74
00:03:55,020 --> 00:03:58,840
>> కాబట్టి ఒక డో-సమయంలో లూప్ అమలు
లూప్ యొక్క శరీరం, కనీసం

75
00:03:58,840 --> 00:04:01,750
మరియు అప్పుడు అది చూసేందుకు తనిఖీ
అది అమలు లేదో,

76
00:04:01,750 --> 00:04:05,310
ఒక సమయంలో లూప్ వ్యతిరేకంగా,
పరిస్థితి తనిఖీ చేస్తుంది

77
00:04:05,310 --> 00:04:07,200
ఆపై శరీరం అమలు.

78
00:04:07,200 --> 00:04:11,880
కాబట్టి ఒక డో-సమయంలో లూప్ లో మనం వాటిని
అలా పూర్ణాంకం కోసం వినియోగదారు ప్రాంప్ట్ ఉంది,

79
00:04:11,880 --> 00:04:14,450
ఆపై అది చెల్లదు అయితే లేదా తనిఖీ.

80
00:04:14,450 --> 00:04:18,130
చెల్లని ఉంటే, అప్పుడు మేము చేస్తాము
యూజర్ అడగడం విధానాన్ని పునరుక్తి

81
00:04:18,130 --> 00:04:22,290
మాకు మరొక పూర్ణాంకం ఇస్తాయి, మరియు అప్పుడు
ఆ పూర్ణాంక చెల్లదు మాత్రమే,

82
00:04:22,290 --> 00:04:25,060
మేము కొనసాగిస్తాము
సంసార తరువాత వస్తుంది.

83
00:04:25,060 --> 00:04:28,030
>> ఇప్పుడు మీరు గమనించవచ్చు
పూర్ణసంఖ్య n ప్రకటన

84
00:04:28,030 --> 00:04:31,670
కొద్దిగా భిన్నంగా ఉంటుంది మనం
మునుపటి ఉదాహరణలో ముందు చేశాడు

85
00:04:31,670 --> 00:04:33,640
మరియు ఈ కారణంగా స్కోప్ ఉంది.

86
00:04:33,640 --> 00:04:37,920
మేము లోపల పూర్ణాంకం n ప్రకటించారు
డో-సమయంలో లూప్ యొక్క శరీరం యొక్క,

87
00:04:37,920 --> 00:04:42,640
అప్పుడు మేము యాక్సెస్ చేయలేరు అని
ఆ వంకర బయట n యొక్క ఆ విలువ

88
00:04:42,640 --> 00:04:45,050
లూప్ యొక్క శరీరం సూచిస్తూ జంట కలుపులు.

89
00:04:45,050 --> 00:04:51,080
కానీ మేము నిజానికి యాక్సెస్ అనుకుంటున్నారు
n విలువ తరువాత మా కార్యక్రమం లో.

90
00:04:51,080 --> 00:04:55,730
>> OK, కాబట్టి ఇప్పుడు యొక్క గురించి మాట్లాడటానికి వీలు
ఈ పరిస్థితి ఏ విధంగా ఉండాలి.

91
00:04:55,730 --> 00:05:00,400
మాత్రమే మేము reprompt కావలసిన
యూజర్ కాలం n చెల్లదు వంటి.

92
00:05:00,400 --> 00:05:04,640
కాబట్టి మీరే అనుకుంటున్నాను చెల్లని ఏమి
పూర్ణ సంఖ్య విలువ లాగా

93
00:05:04,640 --> 00:05:08,060
ఆపై ఒక బూలియన్ సృష్టించడానికి
ఆ వ్యక్తం వ్యక్తీకరణ.

94
00:05:08,060 --> 00:05:13,070
>> మేము దాదాపు మన subtask తో పనయ్యాక
ప్రాంప్ట్ మరియు యూజర్ ఇన్పుట్ నిర్ధారించడంలో.

95
00:05:13,070 --> 00:05:16,010
కాబట్టి యొక్క ఈ కొద్దిగా తయారు చేద్దాము
బిట్ మరింత యూజర్ ఫ్రెండ్లీ

96
00:05:16,010 --> 00:05:18,390
మరియు యూజర్ కొద్దిగా ఇవ్వాలని
బిట్ మరింత సమాచారం

97
00:05:18,390 --> 00:05:20,510
మనం వాటిని ప్రోత్సహించాడు.

98
00:05:20,510 --> 00:05:24,500
కాబట్టి యొక్క శాతం, యూజర్ అడుగనివ్వండి
స్పెక్ స్ట్రింగ్ నిమిషాలకు.

99
00:05:24,500 --> 00:05:28,935
సో మీ printf ప్రకటనలు ఉపయోగించి, తయారు
మీరు ఖచ్చితంగా ఈ మ్యాచ్ నిర్ధారించుకోండి.

100
00:05:28,935 --> 00:05:30,230
>> అయితే సరే.

101
00:05:30,230 --> 00:05:33,840
కాబట్టి ఇప్పుడు మేము ఒక చెల్లుబాటు అయ్యే యూజర్
ఇన్పుట్, ఒక సానుకూల పూర్ణాంక

102
00:05:33,840 --> 00:05:37,400
ఎన్ని నిమిషాలు విలువ
వారు షవర్ లో గడిపాడు.

103
00:05:37,400 --> 00:05:41,300
కాబట్టి తరువాత ఏమిటి లెక్కించేందుకు ఉంటుంది
సీసాలు సమానం సంఖ్య.

104
00:05:41,300 --> 00:05:45,250
మనం ఇక్కడ ఏమి చూడాలని
మొదటి వద్ద మీరు చాలా స్పష్టమైన,

105
00:05:45,250 --> 00:05:46,640
మరియు ఆ సరే.

106
00:05:46,640 --> 00:05:49,320
మనం చేయాలనుకుంటున్నారా మేము ఉంది
సాధన ప్రారంభించడానికి కావలసిన

107
00:05:49,320 --> 00:05:53,810
నమూనాలను గుర్తించడం ఆలోచన
సమస్య కోసం సూత్రాలు అభివృద్ధి.

108
00:05:53,810 --> 00:05:57,200
>> కాబట్టి మేము స్పెక్ ప్రతి చెప్పారు చేస్తున్నారు
షవర్ లో అని ఒక నిమిషం

109
00:05:57,200 --> 00:05:59,960
గురించి సమానం
నీటి 12 సీసాలు.

110
00:05:59,960 --> 00:06:03,020
ఆ విధంగా రెండు నిమిషాల చేస్తాను
24 సమానం,

111
00:06:03,020 --> 00:06:05,850
ఐదు నిమిషాల చేస్తాను
60 సమానం.

112
00:06:05,850 --> 00:06:08,390
కాబట్టి ఇప్పుడు మీరు అనుకుంటే
మీరు వచ్చింది చేసిన, అప్పుడు చేసుకుందాం

113
00:06:08,390 --> 00:06:10,390
మీరు పైకి వచ్చి లేదో చూడటానికి
ఒక నమూనా లేదా ఫార్ములా

114
00:06:10,390 --> 00:06:14,990
మేము చెప్పటానికి కలిగి ఉంటే వ్యక్తం, n
నిమిషాలు, ఎన్ని నీటి సీసాలు

115
00:06:14,990 --> 00:06:17,930
ఆ n పరంగా వ్యక్తం అవుతుంది?

116
00:06:17,930 --> 00:06:20,680
>> మళ్ళీ, కూడా ఈ
మొదటి వద్ద సాధారణ,

117
00:06:20,680 --> 00:06:23,240
తరువాత మేము వెళ్ళాక న
మరింత క్లిష్టంగా సమస్యలు

118
00:06:23,240 --> 00:06:26,360
మేము పొందడానికి కావలసిన చూడాలని
గుర్తించే పద్ధతి

119
00:06:26,360 --> 00:06:30,120
నమూనాలు మరియు అభివృద్ధి సూత్రాలు
ఈ విషయాలు బయటకు దొరుకుతుందని.

120
00:06:30,120 --> 00:06:33,450
>> సి లో మీరు యాక్సెస్
ప్రామాణిక అంక కార్యకలాపాలు,

121
00:06:33,450 --> 00:06:36,520
కూడిక, తీసివేత,
గుణకారం మరియు భాగహారం.

122
00:06:36,520 --> 00:06:38,420
కాబట్టి నేను చెప్పను
మీరు ఇప్పుడు దొరుకుతుందని

123
00:06:38,420 --> 00:06:41,300
వ్యక్తపరచటానికి ఎలా
సీసాలు సమానం సంఖ్య

124
00:06:41,300 --> 00:06:43,990
యూజర్ సేవించాలి
వారి షవర్ సమయంలో.

125
00:06:43,990 --> 00:06:45,700
>> అన్ని కుడి, మేము దాదాపు పూర్తి చేసిన.

126
00:06:45,700 --> 00:06:50,650
మేము వారి ఇన్పుట్ వినియోగదారుని ప్రాంప్ట్ చేసిన,
మేము అది చెల్లుబాటు అయ్యే ఇన్పుట్ అని నిర్ధారిస్తుంది చేసిన,

127
00:06:50,650 --> 00:06:53,330
ఆపై మేము ఎలా కనుగొన్నారు చేసిన
సమానమైన లెక్కించేందుకు

128
00:06:53,330 --> 00:06:55,480
వారు వినియోగించిన సీసాల సంఖ్య.

129
00:06:55,480 --> 00:06:59,430
అలా చేసిన చివరి విషయం అవుట్పుట్ ఉంది
సీసాలు సమానం సంఖ్య

130
00:06:59,430 --> 00:07:02,410
మరియు ఆశాజనక ప్రోత్సహిస్తున్నాము
వాటిని కొన్ని నీటిని ఆదా చేసే.

131
00:07:02,410 --> 00:07:06,270
>> విలువ ఉంటుంది ఔట్పుట్
ఒక printf ప్రకటన.

132
00:07:06,270 --> 00:07:09,720
నేను మీరు నేను చెప్పడం కోరుకుంటే
ఉదాహరణకు, మూడు పెంపుడు జంతువులు,

133
00:07:09,720 --> 00:07:13,090
నేను ఒక printf ప్రకటన ఉపయోగించుకునే
ఈ వంటి ఏదో కనిపిస్తోంది.

134
00:07:13,090 --> 00:07:15,880
నేను మూడు పెంపుడు జంతువులు, మరియు ఒక కొత్త
నైస్ ఫార్మాటింగ్ కోసం లైన్.

135
00:07:15,880 --> 00:07:17,880
>> ఇప్పుడు మేము వద్దు
కేవలం హార్డ్ కోడ్ విషయాలు.

136
00:07:17,880 --> 00:07:20,740
సంఖ్య సే నా
పెంపుడు జంతువులు కాలక్రమేణా మార్పులు.

137
00:07:20,740 --> 00:07:25,080
అప్పుడు నేను వినియోగించుకోవచ్చు వెళుతున్న
నా printf ప్రకటనలో placeholders.

138
00:07:25,080 --> 00:07:27,350
ఇక్కడ నా సంఖ్య ఒక పూర్ణ సంఖ్య.

139
00:07:27,350 --> 00:07:31,480
నేను ఒక ప్లేస్హోల్డర్ చేయడానికి వెళుతున్న
% నేను ఉపయోగించి పూర్ణాంకం.

140
00:07:31,480 --> 00:07:33,930
నేను స్ట్రింగ్ రాయాలో,
మరియు తరువాత స్ట్రింగ్ తరువాత

141
00:07:33,930 --> 00:07:38,000
నేను ఒక కామా మరియు వ్రాయడం
నేను ముద్రించడానికి కావలసిన వేరియబుల్.

142
00:07:38,000 --> 00:07:42,730
ఆ విలువ ప్రింట్ చేయబడుతుంది కాబట్టి
ఆ ప్లేస్హోల్డర్% నేను బదులుగా లో.

143
00:07:42,730 --> 00:07:47,630
>> మీరు, placeholders ఉపయోగించవచ్చు
బాగా, ఒక% విదే తేలియాడుతున్న.

144
00:07:47,630 --> 00:07:50,420
మీరు కూడా బహుళ ఉండవచ్చు
ఒక స్ట్రింగ్ లో placeholders.

145
00:07:50,420 --> 00:07:53,950
ఉదాహరణకు, నేను కొన్ని సంఖ్య ఉంటే
కుక్కలు మరియు పిల్లుల కొన్ని సంఖ్య,

146
00:07:53,950 --> 00:07:59,210
నేను ఇక్కడ మరియు తరువాత రెండు placeholders చాలు
సంబంధిత క్రమంలో నా రెండు వేరియబుల్స్.

147
00:07:59,210 --> 00:08:03,130
>> కాబట్టి ఇప్పుడు మేము ప్రింట్ ఎలా తెలుసు
వేరియబుల్స్ నిల్వ విలువలు,

148
00:08:03,130 --> 00:08:06,030
చాలా చివరి విషయం
అలా మేము నిర్ధారించడానికి ఉంది

149
00:08:06,030 --> 00:08:10,920
ఖచ్చితమైన ఫార్మాట్ విలువ ముద్రించడానికి
వివరణలో సూచించింది.

150
00:08:10,920 --> 00:08:14,990
అంతటితో ప్రాంప్ట్ చేసిన
వినియోగదారు మరియు వారి ఇన్పుట్ చెల్లుబాటు.

151
00:08:14,990 --> 00:08:17,920
మేము అప్పుడు సమానం లెక్కించిన చేసిన
నీటి సీసాల సంఖ్య

152
00:08:17,920 --> 00:08:22,100
వారు వారి షవర్ సమయంలో తింటాయి,
మరియు మేము వాటిని ఆ విలువ outputted చేసిన.

153
00:08:22,100 --> 00:08:24,440
అందువలన, మేము నీరు పూర్తి చేసిన.

154
00:08:24,440 --> 00:08:28,730
>> నా పేరు [? Zamila?]
మరియు ఈ CS50 ఉంది.

155
00:08:28,730 --> 00:08:29,909