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
./integer.

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
વેલ, બધા અમે કરીશ સ્ટોર છે
એક ચલ આ કિંમત, એ કહે છે.

49
00:02:25,260 --> 00:02:30,580
તેથી જો હું પૂર્ણાંક n એ જાહેર,
અને હું get_int કે કિંમત સુયોજિત કરો,

50
00:02:30,580 --> 00:02:34,700
પછી એ પછી સ્ટોર કરશે ગમે
વપરાશકર્તા ઇનપુટ કદર છે.

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
પછી અમે ઍક્સેસ કરવા માટે સમર્થ નહિં હોય
તે સર્પાકાર બહાર એ છે કે કિંમત

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
વ્યક્ત જો આપણે કહે છે, એ
મિનિટ, કેટલા પાણીની બોટલ

115
00:06:14,990 --> 00:06:17,930
કે એ દ્રષ્ટિએ વ્યક્ત કરવામાં આવશે?

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
અને પછી અમે બહાર કેવી રીતે figured કર્યું
સમકક્ષ ગણતરી માટે

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
>> તમે જગ્યામાં ઉપયોગ કરી શકો છો, કારણ કે
વેલ, એક% એફ સાથે ફ્લોટ્સ છે.

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