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

2
00:00:00,500 --> 00:00:01,960
காண்க: 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
எனவே நாம் அடங்கும் HASHTAG வேண்டும்
பொருட்டு அதன் அறிவிப்பு

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
>> சரி, அதனால் இப்போது நான் பற்றி பேசுகிறேன்
என்ன இந்த நிலையில் இருக்க வேண்டும்.

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
>> மதிப்பு வேண்டும் outputting
ஒரு 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 அறிக்கையில் பெட்டிகள்.

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
>> நீங்கள், பெட்டிகள் பயன்படுத்த முடியும்
நன்றாக, ஒரு,% f கொண்டு மிதவைகள்.

144
00:07:47,630 --> 00:07:50,420
நீங்கள் பல இருக்க முடியும்
ஒரு சரம் இல் பெட்டிகள்.

145
00:07:50,420 --> 00:07:53,950
உதாரணமாக, நான் சில பல வேண்டும் என்றால்
நாய்கள் மற்றும் பூனைகள் சில பல,

146
00:07:53,950 --> 00:07:59,210
நான் இங்கே பின்னர் இரண்டு பெட்டிகள் வைத்து
அந்தந்த பொருட்டு என் இரண்டு மாறிகள்.

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