1
00:00:00,000 --> 00:00:02,830
>> SPEAKER 1: యొక్క ఒక ప్రోగ్రామ్ను రాయడం లెట్
సానుకూల కోసం ప్రాంప్టుచేస్తుంది

2
00:00:02,830 --> 00:00:05,950
అప్పుడు పూర్ణాంకం, n, మరియు ముద్రిస్తుంది
అన్ని సంఖ్యల మొత్తం

3
00:00:05,950 --> 00:00:07,980
1 మధ్య మరియు n.

4
00:00:07,980 --> 00:00:10,580
సరే, ఇక్కడ మేము నేను ఇది, ప్రధాన కలిగి
ఇప్పటికే ముందుగానే వ్రాసిన.

5
00:00:10,580 --> 00:00:13,520
మరియు ఇక్కడ గమనించవచ్చు ఎగువన
ప్రధాన, నేను ఒక పూర్ణాంకానికి n డిక్లేర్.

6
00:00:13,520 --> 00:00:16,079
>> నేను, ఒక విధంగా లోపలి
లూప్, మొదటి ప్రింట్

7
00:00:16,079 --> 00:00:17,530
సానుకూల పూర్ణాంక, దయచేసి.

8
00:00:17,530 --> 00:00:21,070
అప్పుడు నేను నుండి ఒక పూర్ణ సంఖ్య వెళ్లండి
CS50 లైబ్రరీ యొక్క గెట్ యూజర్

9
00:00:21,070 --> 00:00:22,070
ఫంక్షన్ Int.

10
00:00:22,070 --> 00:00:26,410
ఆపై నా పరిస్థితి లో ఇక్కడ, నేను
n కంటే ఎక్కువ లేదా అని నిర్ధారించడానికి

11
00:00:26,410 --> 00:00:30,480
నిజానికి కొనసాగుటకు ముందుగా 1 సమానంగా
ఆ విలువ ఏదో ఒకటి చేయాలని.

12
00:00:30,480 --> 00:00:31,520
>> నేను తరువాత ఏమి చెయ్యాలి?

13
00:00:31,520 --> 00:00:34,690
బాగా, నేను వెళుతున్న ఒక ఫంక్షన్ కాల్
సిగ్మా, ప్రతినిధి కాల్

14
00:00:34,690 --> 00:00:37,700
మీరు కలిగి ఉండవచ్చు రాజధాని సిగ్మా
గణిత తరగతులు పిలిపించారు అని

15
00:00:37,700 --> 00:00:40,860
మీరు ఏదో సంకలనం చేయదలిచిన సూచిస్తుంది
మరొక విలువ నుండి.

16
00:00:40,860 --> 00:00:44,540
మరియు సంసార ఆ ఫంక్షన్ తిరిగి వంటి
దాని తిరిగి విలువ, నేను నిల్వ వెళుతున్న

17
00:00:44,540 --> 00:00:46,500
సమాధానం అనే వేరియబుల్.

18
00:00:46,500 --> 00:00:50,280
>> చివరగా, ప్రధాన లో చివరి లైన్ లో, నేను ఉన్నాను
సమాధానం ఏమిటో ప్రింట్ అన్నారు.

19
00:00:50,280 --> 00:00:52,840
వాస్తవానికి, మేము ఇంకా అమలు చేయలేదు
ఈ ఫంక్షన్ సిగ్మా.

20
00:00:52,840 --> 00:00:54,590
కాబట్టి మేము ఎలా ఆ చేయడం గురించి గో?

21
00:00:54,590 --> 00:00:58,040
>> బాగా, నా ఫైలు దిగువన, నేను ఉన్నాను
ఒక సీ వెళ్లండి అన్నారు

22
00:00:58,040 --> 00:00:59,450
ఒక పూర్ణాంకానికి తిరిగి.

23
00:00:59,450 --> 00:01:01,630
నేను కాల్ వెళుతున్న
ఆ ఫంక్షన్ సిగ్మా.

24
00:01:01,630 --> 00:01:06,340
నేను ఇన్పుట్ ఆ తెలుపుటకు వెళుతున్న
ఆ ఫంక్షన్ కూడా ఒక Int అంగీకరిస్తుంది.

25
00:01:06,340 --> 00:01:09,800
మరియు నేను, కేవలం కాల్ చేస్తాము
బదులుగా n యొక్క ప్రత్యేక, m.

26
00:01:09,800 --> 00:01:12,120
కానీ మేము అది అని ఉండవచ్చు
మేము భావిస్తున్న అత్యంత ఏదైనా.

27
00:01:12,120 --> 00:01:14,930
>> నేను ఈ పనితీరు శరీరం లోపలి
ఒక తెలిసిన ఉపయోగించడానికి ముందుకు అన్నారు

28
00:01:14,930 --> 00:01:16,420
, అవి ఒక లూప్ నిర్మిస్తారు.

29
00:01:16,420 --> 00:01:19,010
కానీ నేను కూడా తెలివి యొక్క ఒక బిట్ వెళుతున్న
నిర్ధారించుకోండి తనిఖీ

30
00:01:19,010 --> 00:01:22,340
యూజర్ అనేక నాకు అందించడం లేదు
నేను ఆశించే లేదు అని.

31
00:01:22,340 --> 00:01:28,010
M ఉంటే ముఖ్యంగా, నేను వెళుతున్న
కంటే తక్కువ 1, కొంతవరకు ఏకపక్ష,

32
00:01:28,010 --> 00:01:31,280
నేను కేవలం 0 ఉంటే తిరిగి వెళుతున్న
సంఖ్య అనుకూల కాదు

33
00:01:31,280 --> 00:01:32,800
నేను వంటి పూర్ణాంక.

34
00:01:32,800 --> 00:01:36,920
>> అప్పుడు నేను ఒక వేరియబుల్ డిక్లేర్ వెళుతున్న
అని మొత్తం మరియు 0 దాన్ని ప్రారంభించడం.

35
00:01:36,920 --> 00:01:40,810
ఇది చివరికి మొత్తం ఆఫ్ నిల్వ చేస్తుంది
1 మరియు m మధ్య సంఖ్యల అన్ని.

36
00:01:40,810 --> 00:01:43,550
ఆపై నేను ఒక పరిచయం వెళుతున్న
ముందుకు లూప్ నిర్మాణం.

37
00:01:43,550 --> 00:01:50,272
నేను 1 గెట్స్ Int కోసం, నేను కంటే తక్కువ
లేదా m సమానంగా, నేను ప్లస్ ప్లస్.

38
00:01:50,272 --> 00:01:54,010
మరియు తరువాత, ఈ యొక్క భాగంలోనే
లూప్, నేను కేవలం మొత్తం వెళుతున్న

39
00:01:54,010 --> 00:01:56,350
మొత్తం మరియు నేను సమానం.

40
00:01:56,350 --> 00:02:01,900
లేదా, కేవలం, మొత్తం మరియు, నేను సమానం
ఇది అదే ఫలితం సాధిస్తుంది.

41
00:02:01,900 --> 00:02:04,810
>> మరియు తర్వాత చివరగా, నేను తిరిగి అవసరం
నేను కంప్యూటెడ్ చేసిన మొత్తం.

42
00:02:04,810 --> 00:02:07,640
నేను తిరిగి మొత్తంగా జోడించండి.

43
00:02:07,640 --> 00:02:08,560
>> ఇప్పుడు నేను ఇంకా పూర్తి కాదు.

44
00:02:08,560 --> 00:02:11,360
నేను సి బోధించడానికి అవసరమైన ఈ
ఫంక్షన్ వాస్తవానికి ఉంది.

45
00:02:11,360 --> 00:02:14,400
కాబట్టి నా ఫైలు పైన నేను డిక్లేర్ వెళుతున్న
మేము ఒక ఫంక్షన్ అనే వాటిని

46
00:02:14,400 --> 00:02:18,270
సంతకం సమానంగా నమూనా,
ఫంక్షన్ నిర్వచించు నేను ఉపయోగించిన

47
00:02:18,270 --> 00:02:19,250
ఒక క్షణం క్రితం.

48
00:02:19,250 --> 00:02:22,450
>> ముఖ్యంగా, కేవలం ప్రధాన పై,
నేను Int టైప్ వెళుతున్న

49
00:02:22,450 --> 00:02:26,080
సిగ్మా, Int m, సెమికోలన్.

50
00:02:26,080 --> 00:02:29,240
ఫంక్షన్ అమలు కాదు
మళ్ళీ, కేవలం అది ప్రకటించారు.

51
00:02:29,240 --> 00:02:32,800
నేను ఇప్పుడు సేవ్ ఉంటే, కంపైల్, ఈ అమలు
కార్యక్రమం నేను పొందండి చూద్దాం.

52
00:02:32,800 --> 00:02:37,460
సిగ్మా 0 డాట్ సిగ్మా 0 స్లాష్ చేయండి.

53
00:02:37,460 --> 00:02:41,050
ఇప్పుడు యొక్క సానుకూల పూర్ణాంక అందించడానికి వీలు
వంటి 2, ఇది నాకు ఇవ్వాలి

54
00:02:41,050 --> 00:02:45,920
మూడు, విలువల మధ్య ఎందుకంటే
1 మరియు 2 1 ప్లస్ 2 3 సమానం.

55
00:02:45,920 --> 00:02:47,300
నిజానికి, ఆ నేను పొందండి ఉంది.

56
00:02:47,300 --> 00:02:49,940
>> యొక్క ఈ, మళ్ళీ అమలు లెట్
3, సే, తో.

57
00:02:49,940 --> 00:02:53,470
నేను 1 2 ప్లస్ ప్లస్ కావాలి
3 నాకు 6 ఇవ్వాలి.

58
00:02:53,470 --> 00:02:54,740
నిజానికి, నేను 6 వస్తుందా.

59
00:02:54,740 --> 00:02:57,380
>> మరియు యొక్క ఒక చివరి విలువ ప్రయత్నించండి, 50 సే.

60
00:02:57,380 --> 00:03:01,160
మరియు 1,275 మా సమాధానం.

61
00:03:01,160 --> 00:03:02,253