1
00:00:00,000 --> 00:00:00,340

2
00:00:00,340 --> 00:00:02,690
>> DAVID మలన్: మేము రాయడానికి కావలసిన అనుకుందాం
ప్రాంప్టుచేస్తుంది ఒక కార్యక్రమం

3
00:00:02,690 --> 00:00:05,100
అప్పుడు స్ట్రింగ్ మరియు క్యాపిటల్ కోసం
ఆ స్ట్రింగ్.

4
00:00:05,100 --> 00:00:09,000
Well, కొన్ని తెలిసిన ప్రారంభిద్దాం
కోడ్ s అనే స్ట్రింగ్ ప్రకటించారు

5
00:00:09,000 --> 00:00:11,380
అది తిరిగి కేటాయించి
GetString విలువ.

6
00:00:11,380 --> 00:00:14,910
మరియు ఇప్పుడు పై iterate ముందుకు తెలపండి
ఈ స్ట్రింగ్ లో అక్షరాలు.

7
00:00:14,910 --> 00:00:16,000
బాగా, అలా?

8
00:00:16,000 --> 00:00:19,350
ఇది ఒక స్ట్రింగ్ కేవలం ఒక అని అవుతుంది
అక్షరాలు క్రమం, కానీ మరింత

9
00:00:19,350 --> 00:00:23,320
సరిగా, ఒక స్ట్రింగ్ యొక్క వ్యూహం ఉంది
మేము ఉపయోగించవచ్చు అంటే అక్షరాలు,

10
00:00:23,320 --> 00:00:27,590
లోకి సూచిక చదరపు బ్రాకెట్ సంజ్ఞామానం
ఒక స్ట్రింగ్ మరియు వ్యక్తిగత దొరకని

11
00:00:27,590 --> 00:00:28,680
అక్షరాలు.

12
00:00:28,680 --> 00:00:30,980
>> ఇతర మాటలలో, మేము
క్రింది వాటిని.

13
00:00:30,980 --> 00:00:36,730
Int కోసం, నేను, 0 వస్తుంది, మరియు n గెట్స్
ఉపయోగించి,, s యొక్క పొడవు చెప్పటానికి

14
00:00:36,730 --> 00:00:37,530
మా ఫంక్షన్ [? కదిలించు?]

15
00:00:37,530 --> 00:00:38,630
[? లైన్,?]

16
00:00:38,630 --> 00:00:40,450
నేను + + n కంటే తక్కువ.

17
00:00:40,450 --> 00:00:45,290
ఈ లూప్ తో ఇతర పదాలు,, మేము
అన్ని n అక్షరాలు మీద iterate ఉంటుంది

18
00:00:45,290 --> 00:00:46,670
స్ట్రింగ్ s లో.

19
00:00:46,670 --> 00:00:51,680
మరియు ఈ లూప్ లోపల, నేను వెళుతున్న
, గమనించినట్లయితే లు లో i-th పాత్ర

20
00:00:51,680 --> 00:00:57,630
కంటే ఎక్కువ లేదా ఒక చిన్న సమానంగా,
i-th పాత్ర కంటే తక్కువ లేదా ఉంది

21
00:00:57,630 --> 00:01:02,370
ఒక చిన్న సి సమానంగా, నేను కావలసిన
ఆ లేఖ చూపడంలో కొనసాగండి.

22
00:01:02,370 --> 00:01:08,030
ఇతర మాటలలో, నేను% సి ప్రింట్ మీరు
కోసం ఒక హోల్డర్ మరియు ప్రత్యామ్నాయంగా

23
00:01:08,030 --> 00:01:11,120
ఆ హోల్డర్ లు బ్రాకెట్ నేను.

24
00:01:11,120 --> 00:01:14,390
>> కానీ నేను మార్చేందుకు అవసరం
లు బ్రాకెట్ నేను పెద్ద.

25
00:01:14,390 --> 00:01:18,930
ఇది చేయుటకు, నేను కేవలం తీసివేయడం చేయవచ్చు
తేడా మధ్య ఏమైనా

26
00:01:18,930 --> 00:01:24,120
చిన్న ఒక మరియు రాజధాని స
నిజానికి రాజధాని అని గుర్తు లేదు

27
00:01:24,120 --> 00:01:27,160
ASCII లో 65, మరియు చిన్న ఒక 97 ఉంది.

28
00:01:27,160 --> 00:01:29,210
కాబట్టి తేడా సాంకేతికంగా 32.

29
00:01:29,210 --> 00:01:31,620
నేను ఇక్కడ కేవలం హార్డ్ కోడ్ 32 అనుకొనుట.

30
00:01:31,620 --> 00:01:33,870
కానీ నేను అవసరం వాటిని
ఆ నంబర్లు గుర్తు.

31
00:01:33,870 --> 00:01:37,250
>> మరియు సాగే, ఏ వారు
కంప్యూటర్ మారుతూ ఉంటాయి?

32
00:01:37,250 --> 00:01:38,520
ఎక్కువగా వారు లేదు.

33
00:01:38,520 --> 00:01:42,460
కానీ పాయింట్ నేను ఇంకా అని ఉంది
అంకగణితం వ్యక్తీకరణ సాధారణీకరించి

34
00:01:42,460 --> 00:01:46,550
అంతే తేడా ఏమైనా
ఒక చిన్న ఒక మరియు ఒక రాజధాని మధ్య

35
00:01:46,550 --> 00:01:50,880
నేను నుండి వ్యవకలనం కావలసిన ఏమిటి
ఈ ప్రత్యేక చిన్న లేఖ.

36
00:01:50,880 --> 00:01:54,500
>> ఇప్పుడు, ఈ ప్రత్యేక లేఖ
చిన్న లేదు, నేను కేవలం

37
00:01:54,500 --> 00:01:56,620
దాన్ని ప్రింట్ మీరు.

38
00:01:56,620 --> 00:02:01,110
printf, నా హోల్డర్ వంటి% సి,
లు బ్రాకెట్ నేను.

39
00:02:01,110 --> 00:02:05,150
ఈ కార్యక్రమం దిగువన, లెట్స్
కేవలం NEWLINE ప్రింట్ కాబట్టి నా

40
00:02:05,150 --> 00:02:07,520
ప్రాంప్ట్ ఒక కొత్త కనిపిస్తుంది
తన సొంత లైన్.

41
00:02:07,520 --> 00:02:11,540
>> యొక్క ఇప్పుడు ఈ ప్రోగ్రామ్ కంపైల్ తెలియజేయండి
తయారు capitalize0 తో.

42
00:02:11,540 --> 00:02:13,900
యొక్క capitalize0 తో అమలు లెట్.

43
00:02:13,900 --> 00:02:17,190
మరియు యొక్క వంటి ఒక పదం లో టైప్
హలో అన్ని చిన్న లో.

44
00:02:17,190 --> 00:02:19,960
నేను పెద్ద లో HELLO తిరిగి
అనుకున్న.

45
00:02:19,960 --> 00:02:25,210
కానీ యొక్క ఒక మరింత పరీక్ష, ఈ సమయంలో ప్రయత్నించండి
నా సొంత పేరుతో, D-A-V-I-D, కానీ తో

46
00:02:25,210 --> 00:02:28,170
మొదటి D కేవలం లో, క్యాపిటల్
కేసు నేను ఏదో గందరగోళంలో

47
00:02:28,170 --> 00:02:29,430
మొదటి చార్.

48
00:02:29,430 --> 00:02:34,250
పెద్ద లో ఎంటర్, మరియు D-A-V-I-D
అలాగే ముద్రించబడుతుంది.

49
00:02:34,250 --> 00:02:36,873