1
00:00:00,000 --> 00:00:00,400

2
00:00:00,400 --> 00:00:02,720
>> సల ప్రతిదీ గుర్తు
ఒక కంప్యూటర్ యొక్క హుడ్ ఉంది కింద

3
00:00:02,720 --> 00:00:03,900
బిట్స్ ఉపయోగించి నిల్వ.

4
00:00:03,900 --> 00:00:06,320
మరియు బిట్స్, క్రమంగా, ఉపయోగించవచ్చు
సంఖ్యలు ప్రాతినిధ్యం.

5
00:00:06,320 --> 00:00:09,020
మరియు సంఖ్యలను, క్రమంగా, ఉపయోగించవచ్చు
అక్షరాలు ప్రాతినిధ్యం.

6
00:00:09,020 --> 00:00:12,530
నిజానికి, ఒక సంప్రదాయ ఉంది
ఆ సంఖ్యలు మధ్య మ్యాపింగ్

7
00:00:12,530 --> 00:00:14,260
అక్షరాలు, ASCII అని -

8
00:00:14,260 --> 00:00:17,130
అమెరికన్ స్టాండర్డ్ కోడ్
సమాచార వినిమయం.

9
00:00:17,130 --> 00:00:20,460
>> ఇప్పుడు సి తో, అది మేము చూడగలరు అవుతుంది
ఈ సమాన, ఎందుకంటే మేము కాదు

10
00:00:20,460 --> 00:00:24,400
మాత్రమే ints కలిగి, మేము కూడా రెండు అక్షరాలు కలిగి
వీటిలో రోజు చివరిలో

11
00:00:24,400 --> 00:00:27,240
సంఖ్యలు సూచించబడతాయి
మరియు, క్రమంగా, బిట్స్.

12
00:00:27,240 --> 00:00:30,850
కాబట్టి యొక్క ఒక సాధారణ ప్రోగ్రామ్ వ్రాయుటకు అనుమతి అని
కేవలం మ్యాపింగ్ ఉంది నాకు చెబుతుంది

13
00:00:30,850 --> 00:00:37,650
సంఖ్యలు మరియు అక్షరాలు మధ్య, లో ఉంచడం
65 ఒక ఒక రాజధాని మరియు 97 అని పట్టించుకోవడం

14
00:00:37,650 --> 00:00:39,080
తక్కువ కేసు ఒక ఉంది.

15
00:00:39,080 --> 00:00:40,630
యొక్క ప్రారంభించండి.

16
00:00:40,630 --> 00:00:49,680
>> "ప్రామాణిక I / O డాట్ h ఉన్నాయి." "Int
ప్రధాన గర్జన. "ఇప్పుడు నేను చెయ్యాలనుకుంటే

17
00:00:49,680 --> 00:00:53,380
అక్షరాలు అన్ని పైగా iterate
వారి సంఖ్యా మరియు ముద్రించిన

18
00:00:53,380 --> 00:00:54,680
పాత్ర సమానమైన.

19
00:00:54,680 --> 00:00:56,960
ఈ కోసం, నేను ఒక లూప్ "కోసం" ఉపయోగిస్తాము.

20
00:00:56,960 --> 00:00:59,560
"Int కోసం i గెట్స్ -

21
00:00:59,560 --> 00:01:03,120
మరియు ఇప్పుడు, బదులుగా సాధారణ ప్రారంభం
0, నేను ఒక విలువ వద్ద మొదలు లేదు

22
00:01:03,120 --> 00:01:07,130
నేను, ముఖ్యమైన తెలుసు
వంటి రాజధాని కోసం 65?

23
00:01:07,130 --> 00:01:10,300
దీన్ని యొక్క లెట్, కాలం
నేను కంటే తక్కువ ఉంది -

24
00:01:10,300 --> 00:01:10,600
ఉమ్ -

25
00:01:10,600 --> 00:01:17,190
65 ప్లస్ 26, నేను అక్కడ తెలుసు ఎందుకంటే
వర్ణమాలలో 26 అక్షరాలు ఉన్నాయి.

26
00:01:17,190 --> 00:01:20,840
మరియు ఈ యొక్క ప్రతి పునరావృతం న
లూప్, నాకు 1 ద్వారా నేను పెంచడం తెలియజేయండి.

27
00:01:20,840 --> 00:01:23,640
>> ఇప్పుడు, ఈ యొక్క ప్రతి పునరావృతం న
లూప్, నేను ఏమి అనుకుంటున్నారు?

28
00:01:23,640 --> 00:01:27,390
నేను దొరికినవి ప్రింట్ చెయ్యాలనుకుంటే
సంఖ్య i ఉంది మరియు

29
00:01:27,390 --> 00:01:29,570
సంబంధిత చార్.

30
00:01:29,570 --> 00:01:34,920
ఇప్పుడు, ఆ సాధించడానికి, నేను, తారాగణం
మాట్లాడటం, ఒక చార్ పూర్ణాంకానికి

31
00:01:34,920 --> 00:01:37,800
దారి.

32
00:01:37,800 --> 00:01:45,830
లో "ముద్రణ F% i% సి బాక్ స్లాష్ n ఉంది"
ఇతర పదాలు, నేను ఈ అంతరంలో

33
00:01:45,830 --> 00:01:48,350
సంఖ్య ఈ పాత్ర.

34
00:01:48,350 --> 00:01:51,940
నేను ఈ రెండు విలువలు ప్లగ్ అవసరం
కాబట్టి, ముద్రణ F కోసం హోల్డర్స్ ఉంచండి

35
00:01:51,940 --> 00:01:55,130
- నేను కామా నేను, కామా చేస్తాను

36
00:01:55,130 --> 00:01:58,400
>> ఇప్పుడు, నేను ఒక వేరియబుల్ సి లేదా లేదు
ఒక చార్, కానీ నేను అనేక ఉన్నాయి.

37
00:01:58,400 --> 00:02:01,940
నేను సంఖ్యలు వీలు అవుతుంది తెలుసు
అక్షరాలు, నేను కేవలం చెప్పడం అవసరం

38
00:02:01,940 --> 00:02:03,230
అలా కంప్యూటర్.

39
00:02:03,230 --> 00:02:09,020
కాబట్టి నేను ఒక పూర్ణాంకానికి నుండి తారాగణం
కేవలం లో పేర్కొనడం ద్వారా ఒక చార్,

40
00:02:09,020 --> 00:02:12,850
నేను వంటి నిజానికి భావిస్తున్నట్టు కుండలీకరణాలు
ఒక చార్ మార్చుకునేందుకు.

41
00:02:12,850 --> 00:02:17,440
>> యొక్క సేవ్, ఇప్పుడు ఈ ప్రకటన ముసివేద్ధము
ఫైలు, మరియు ప్రోగ్రామ్ తయారు.

42
00:02:17,440 --> 00:02:23,590
"Ascii 0 డాట్ స్లాష్ ascii 0 చేయండి." మరియు
చాలా త్వరగా అది స్క్రీన్ ముద్రించవచ్చు

43
00:02:23,590 --> 00:02:26,760
సంఖ్యలు మరియు మధ్య ఈ మాపింగ్
వారి పాత్ర సమానమైన.

44
00:02:26,760 --> 00:02:31,920
నిజానికి, నేను తిరిగి అప్ స్క్రోల్ చేయండి, నేను మొదటి
65 ఒక ఉందని, 66 B, మరియు నేను

45
00:02:31,920 --> 00:02:35,520
డౌన్ తిరిగి స్క్రోల్, 90 Z. ఉంది

46
00:02:35,520 --> 00:02:35,597