1
00:00:00,000 --> 00:00:00,720

2
00:00:00,720 --> 00:00:03,190
>> డేవిడ్ J. మలన్: నేను ఇష్టపడే అనుకుందాం
ప్రాంప్ట్ చేసే కార్యక్రమం అమలు

3
00:00:03,190 --> 00:00:06,650
అప్పుడు స్ట్రింగ్ కోసం వినియోగదారు మరియు ఉపక్రమించాడు
వారి ఇన్పుట్ చూపడంలో,

4
00:00:06,650 --> 00:00:09,790
ఏ చిన్న అక్షరాలను మార్చడానికి
వారు పెద్ద టైప్ అని.

5
00:00:09,790 --> 00:00:11,770
సరే, ముందుకు తెలియజేయండి మరియు
ఆ కార్యక్రమం అమలు.

6
00:00:11,770 --> 00:00:18,760
>> మొదటి cs50.h తరువాత ఉన్నాయి లెట్
ద్వారా stdio.h ఉన్నాయి.

7
00:00:18,760 --> 00:00:23,990
కాబట్టి మేము, గ్రేట్ అని
యొక్క string.h కలిగి అనుమతిస్తుంది.

8
00:00:23,990 --> 00:00:29,860
>> యొక్క తదుపరి ప్రధాన వంటి Int ప్రధాన గర్జన డిక్లేర్ లెట్
మరియు ఇప్పుడు ప్రాంప్ట్ ముందుకు తెలపండి

9
00:00:29,860 --> 00:00:31,600
ఒక స్ట్రింగ్ కోసం వినియోగదారు.

10
00:00:31,600 --> 00:00:34,840
Printf, యొక్క వాటిని అడుగనివ్వండి
కొన్ని ఇన్పుట్ కోసం.

11
00:00:34,840 --> 00:00:36,460
ఇప్పుడు ఒక స్ట్రింగ్ డిక్లేర్ తెలియజేయండి -

12
00:00:36,460 --> 00:00:37,630
మేము అది s పిలుస్తాను -

13
00:00:37,630 --> 00:00:44,010
మరియు అది లో కాల్ ఫలితంగా నిల్వ
CS50 లైబ్రరీ ఫంక్షన్ GetString.

14
00:00:44,010 --> 00:00:48,850
>> ఇప్పుడు ప్రతి పైగా iterate ముందుకు తెలపండి
లు, కోరుతాయి పాత్రలు

15
00:00:48,850 --> 00:00:50,650
మేము చూసే ఏ చిన్న అక్షరాలను.

16
00:00:50,650 --> 00:00:53,630
Int కోసం, నేను 0 పొందుటకు.

17
00:00:53,630 --> 00:00:58,780
యొక్క కూడా సమానంగా n డిక్లేర్ లెట్
s యొక్క స్ట్రింగ్ పొడవు మేము కాబట్టి

18
00:00:58,780 --> 00:01:03,590
n వరకు నేను నుండి iterate,
s యొక్క పొడవు, మరియు ప్రతి

19
00:01:03,590 --> 00:01:05,760
మళ్ళా నేను పెంచడం.

20
00:01:05,760 --> 00:01:09,970
>> మరియు ఈ లూప్ యొక్క లోపల, లెట్స్
మొదటి తనిఖీ ప్రస్తుత లేఖ ఉంది -

21
00:01:09,970 --> 00:01:12,270
యొక్క i-th లేఖ, మాట్లాడటానికి -

22
00:01:12,270 --> 00:01:14,170
ఒక చిన్న లేఖ.

23
00:01:14,170 --> 00:01:23,090
లు బ్రాకెట్ నేను కంటే ఎక్కువ లేదా సమానంగా ఉంటే
ఒక చిన్న, మరియు అది తక్కువ కు

24
00:01:23,090 --> 00:01:26,900
లేదా చిన్న z సమానంగా -

25
00:01:26,900 --> 00:01:30,860
ఇప్పుడు మేము ఒక చిన్న మార్చేందుకు కావాలా
పెద్ద లేఖ, మొదటి గుర్తు

26
00:01:30,860 --> 00:01:35,810
ASCII లో ఒక చిన్న ఒక 97 ఉంది
మరియు ఒక పెద్ద 65.

27
00:01:35,810 --> 00:01:41,020
ఇంతలో, ఒక చిన్న బి, 98 ఉంది
మరియు ఒక పెద్ద B 66.

28
00:01:41,020 --> 00:01:44,180
>> మేము ఆ నమూనా చూడండి కొనసాగిస్తే,
మేము చూస్తారు చిన్న

29
00:01:44,180 --> 00:01:49,240
అక్షరాలు ఎక్కువ ఎల్లప్పుడూ 32 విలువలు
పెద్ద అక్షరాలు కంటే.

30
00:01:49,240 --> 00:01:53,490
కాబట్టి మేము చిన్న నుండి మార్చేందుకు కావాలా
పెద్ద, అది

31
00:01:53,490 --> 00:01:57,210
వ్యవకలనం, నిజంగా, తగినంత
యూజర్ యొక్క ఇన్పుట్ నుండి 32.

32
00:01:57,210 --> 00:02:01,330
లేక ఎక్కువగా, కేవలం వ్యవకలనం ఆ
ఒక చిన్న ఒక మరియు ఒక మధ్య వ్యత్యాసం

33
00:02:01,330 --> 00:02:02,310
రాజధాని A.

34
00:02:02,310 --> 00:02:03,410
>> ఆ వ్యక్తీకరించడానికి ఎలా?

35
00:02:03,410 --> 00:02:04,640
సరే, కోడ్ లో తెలియజేసేలా.

36
00:02:04,640 --> 00:02:09,960
ముద్రించడానికి printf, కోట్, unquote "% సి"
తర్వాత ప్రస్తుత పాత్ర,

37
00:02:09,960 --> 00:02:18,500
లు బ్రాకెట్ నేను మైనస్ లో ఏమైనా ముద్రణ
చిన్న ఒక చేయడం ఫలితంగా

38
00:02:18,500 --> 00:02:22,660
మైనస్ ఒక సెమికోలన్ పెద్ద.

39
00:02:22,660 --> 00:02:27,010
ఇతర మాటలలో, ఈ parenthetical
వ్యక్తీకరణ, చిన్న ఒక మైనస్ పెద్ద ఒక, ఉంది

40
00:02:27,010 --> 00:02:29,360
మాకు తిరిగి అన్నారు
రోజు 32 ముగింపు.

41
00:02:29,360 --> 00:02:31,230
కానీ నేను గుర్తు లేదు
ఇది 32 అని.

42
00:02:31,230 --> 00:02:34,150
నేను కంప్యూటర్ గుర్తించడానికి అనుమతిస్తుంది
ఏ చిన్న మధ్య వ్యత్యాసం

43
00:02:34,150 --> 00:02:35,990
ఒక మరియు రాజధాని A.

44
00:02:35,990 --> 00:02:39,610
>> ఇంతలో, ఒకసారి నేను, ఆ తేడా తెలుసు
నేను s నుండి వ్యవకలనం చేయవచ్చు

45
00:02:39,610 --> 00:02:43,710
ఏది పడుతుంది బ్రాకెట్ నేను, ఇది
ఒక కు బహుశా ఒక చిన్న లేఖ

46
00:02:43,710 --> 00:02:48,100
ఏజెన్సీలోని మాన ఆ అంటే ఒక విలువ
ఒక పెద్ద సమానమైన లో.

47
00:02:48,100 --> 00:02:51,240
కంపైల్, ఇప్పుడు సేవ్,
ఈ ప్రోగ్రామ్ రన్.

48
00:02:51,240 --> 00:02:57,760
డాట్ స్లాష్ చూపడంలో పెట్టుబడిగా చేయండి.

49
00:02:57,760 --> 00:03:01,290
మరియు నా ఇన్పుట్ హలో ఉంటుంది.

50
00:03:01,290 --> 00:03:02,920
మరియు అక్కడ మేము హలో, కలిగి.

51
00:03:02,920 --> 00:03:05,570
>> ఇప్పుడు నా ప్రాంప్ట్, ఆమోదం
మేము చేసిన ఒక బిట్ అగ్లీ, ఎందుకంటే

52
00:03:05,570 --> 00:03:07,810
ముద్రణ ఒకటి బిట్ విస్మరించబడ్డాయి.

53
00:03:07,810 --> 00:03:09,370
మరియు యొక్క తిరిగి వెళ్లి జోడించడానికి అనుమతిస్తుంది.

54
00:03:09,370 --> 00:03:12,890
ఈ ప్రోగ్రామ్ యొక్క చాలా దిగువన,
నేను చాలా కేవలం, మరియు ఎక్కువగా కోసం రెడీ

55
00:03:12,890 --> 00:03:18,440
సౌందర్య ప్రయోజనం, printf జోడించండి మాత్రం,
కోట్, unquote బాక్ స్లాష్ n.

56
00:03:18,440 --> 00:03:22,330
యొక్క ఈ ఫైలు resave లెట్,
, తిరిగి మళ్ళీ కంపైల్ చెయ్యండి.

57
00:03:22,330 --> 00:03:28,090
>> చూపడంలో చేయండి, డాట్ స్లాష్ చూపడంలో.

58
00:03:28,090 --> 00:03:32,540
మళ్ళీ, ఇన్పుట్ కోసం నేను "హలో" అందిస్తాము
అన్ని తక్కువ కేసులో మరియు ఇప్పుడు, ఎంటర్ నొక్కండి

59
00:03:32,540 --> 00:03:34,550
మరియు "హలో," చాలా సజావుగా ముద్రించిన.

60
00:03:34,550 --> 00:03:36,432