1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Walkthrough - సమస్య సెట్ 2]

2
00:00:01,940 --> 00:00:04,130
[Zamyla చాన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:05,170 --> 00:00:07,490
[ఈ CS50 ఉంది. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
అన్ని కుడి. హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 2 కు స్వాగతం.

5
00:00:10,750 --> 00:00:14,330
మొదటి, నేను pset 1 నిలిచినందుకు మీరు అభినందించటానికి కావలసిన.

6
00:00:14,330 --> 00:00:18,140
నేను, మీరు కొన్ని ఒక బిట్ కఠినమైన ఉండేవి తెలుసు

7
00:00:18,140 --> 00:00:20,460
మీరు రాసిన మీ మొదటి కంప్యూటర్ ప్రోగ్రామ్ ఉండేవి,

8
00:00:20,460 --> 00:00:24,500
కానీ, మీరు సెమిస్టర్ చివరిలో తిరిగి చూడాలని, ఈ చివర గుర్తుంచుకోవాలి

9
00:00:24,500 --> 00:00:29,820
మీరు pset 1 వద్ద పరిశీలిస్తాము మరియు మీరు "అని 5 నిమిషాల్లో. హే, నేను చేసి" సే చేస్తాము

10
00:00:29,820 --> 00:00:35,700
కాబట్టి తెలిసిన మరియు ఈ చివరలో మీరు ఖచ్చితంగా చాలా సరళంగా pset 1 పొందుతారు విశ్వసిస్తున్నాను.

11
00:00:35,700 --> 00:00:40,640
కానీ ఇప్పుడు ఇది ఒక పూర్తియింది, మరియు సద్వినియోగపరచవచ్చు కోసం అభినందనలు.

12
00:00:40,640 --> 00:00:44,010
ఇప్పుడు కూడా త్వరిత గమనిక మేము walkthrough యొక్క మాంసం పొందడానికి ముందు.

13
00:00:44,010 --> 00:00:48,340
నేను కొన్నిసార్లు తగిన సమయం ఉండదు ఒక త్వరిత గమనిక అనుకున్న

14
00:00:48,340 --> 00:00:52,500
పూర్తి వివరణలు సమయంలో సమస్య సెట్ చేయడం ప్రతి ఒక్క మార్గం ద్వారా వెళ్ళడానికి

15
00:00:52,500 --> 00:00:56,140
మరియు కేవలం ఉండవచ్చు ఆచరణలు యొక్క 1 లేదా 2 రకం మీద దృష్టి

16
00:00:56,140 --> 00:00:57,750
మీరు ఈ చేయగల మార్గాలను.

17
00:00:57,750 --> 00:01:01,970
కానీ అది మరొక విధంగా చేయడం నిషేధము కాదు ఉంది.

18
00:01:01,970 --> 00:01:05,980
పనులను అనేక మార్గాలు, కంప్యూటర్ సైన్స్ వలె, తరచుగా ఉన్నాయి

19
00:01:05,980 --> 00:01:12,190
అందువలన కచ్చితంగా నేను అందించిన ఉండవచ్చు కంటే పరిష్కారం యొక్క ఒక భిన్నమైన రకానికి ఉపయోగించడానికి సంకోచించకండి.

20
00:01:12,190 --> 00:01:14,520
[Pset 2: క్రిప్టో - Zamyla చాన్ - zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[Pset2 - 0. ప్రశ్నల యొక్క విభాగం - 1. సీజర్ - 2. విజెనెరే]

22
00:01:17,160 --> 00:01:20,650
అన్ని కుడి. కాబట్టి సమస్య 2 సెట్: క్రిప్టో ఒక ఆహ్లాదకరమైన ఒకటి.

23
00:01:20,650 --> 00:01:24,500
మళ్లీ, ప్రతి pset మీకు ప్రశ్నలు ఒక విభాగం ప్రారంభం చేస్తాము

24
00:01:24,500 --> 00:01:29,600
మీ కేటాయించిన టీచింగ్ తోటి మీ విభాగాలు నిర్వహించిన చేస్తాడు.

25
00:01:29,600 --> 00:01:31,670
మేము, walkthrough పైగా ఈ ద్వారా వెళ్ళడానికి వెళ్ళడం లేదు

26
00:01:31,670 --> 00:01:35,100
కానీ అవి మీరు pset పూర్తి సహాయం చేస్తుంది.

27
00:01:35,100 --> 00:01:38,100
కాబట్టి సమస్య సెట్ మొదటి భాగం సీజర్ ఉంది.

28
00:01:38,100 --> 00:01:43,470
కాబట్టి సీజర్ లో ఎవరైనా, మీరు ఒక పూర్ణాంకం ఒక కీ పాస్ కనిపిస్తుంది

29
00:01:43,470 --> 00:01:48,420
మరియు వారు మీరు అందించే టెక్స్ట్ యొక్క స్ట్రింగ్ గుప్తీకరించును

30
00:01:48,420 --> 00:01:50,670
మరియు ఎన్క్రిప్టెడ్ విషయం వాటిని తిరిగి ఇవ్వండి.

31
00:01:50,670 --> 00:01:56,050
ఎవరైనా క్రిస్మస్ స్టోరీ వీక్షించారు ఉంటే, అక్కడ ఆ యొక్క ఒక ఉదాహరణ ఉంది.

32
00:01:56,050 --> 00:01:59,090
అప్పుడు సమస్య సెట్ రెండవ భాగం, విజెనెరే ఉంది

33
00:01:59,090 --> 00:02:01,790
ఇది మరింత ఆధునిక ఎన్క్రిప్షన్ టెక్నిక్.

34
00:02:01,790 --> 00:02:05,640
కాబట్టి మేము, వచనం యొక్క ఒక భాగాన్ని encipher చూడాలని

35
00:02:05,640 --> 00:02:09,600
బదులుగా కేవలం ఒక పూర్ణాంకం తో తప్ప, మేము దీన్ని ఎన్కోడ్ చూడాలని

36
00:02:09,600 --> 00:02:13,340
యూజర్ మాకు అందించే కీవర్డ్ తో.

37
00:02:16,270 --> 00:02:22,090
సరే, పేజీలు నేడు మొదటి సాధనం వాస్తవానికి ఉపకరణం నవీకరించడాన్ని అవతరిస్తుంది.

38
00:02:22,090 --> 00:02:26,430
చర్చా వేదిక పైన మేము, వంటి వాటిని చూస్తాము "ఎందుకు ఈ పనిచేయటం లేదు?"

39
00:02:26,430 --> 00:02:28,110
"ఎందుకు పని 50 సమర్పించండి లేదు?"

40
00:02:28,110 --> 00:02:31,830
మరియు తరచుగా SOLUTION మీ ఉపకరణం నవీకరించడానికి కేవలం వాస్తవానికి ఉంది.

41
00:02:31,830 --> 00:02:36,730
కాబట్టి మీరు మీ ఉపకరణం సుడో yum-y ఒక టెర్మినల్ విండో లో అమలు చేస్తే -

42
00:02:36,730 --> 00:02:40,040
ఆ అవును వార్తను జెండా యొక్క, ప్రతిదీ update - నవీకరణను,

43
00:02:40,040 --> 00:02:42,280
అవసరం ఉంటే అప్పుడు మీ ఉపకరణం నవీకరిస్తారు.

44
00:02:42,280 --> 00:02:46,960
మీరు ఇప్పటికే ఉపకరణం యొక్క అత్యంత తాజా వెర్షన్ వద్ద ఉంటే మరియు అది బాధిస్తుందని లేదు.

45
00:02:46,960 --> 00:02:51,280
అప్పుడు అది ఏ కొత్త నవీకరణలు అందుబాటులో చెబుతాను మరియు మీరు వెంట పని కొనసాగించవచ్చు.

46
00:02:51,280 --> 00:02:55,800
కానీ ఈ కూడా మీరు ఉపకరణం తెరిచిన ప్రతిసారీ అమలు మంచి ఉంది

47
00:02:55,800 --> 00:02:57,140
మేము ఇంకా చాలా ఉన్నాము ఎందుకంటే -

48
00:02:57,140 --> 00:03:00,320
పరికరంలోని దీన్ని పరిష్కరించడానికి - కొన్నిసార్లు మేము ఒక బగ్ వస్తాయి ఉంటే.

49
00:03:00,320 --> 00:03:03,180
కాబట్టి మీరు ఉపకరణం యొక్క అత్యంత తాజా వెర్షన్ ఉందని నిర్ధారించుకోండి

50
00:03:03,180 --> 00:03:07,710
మరియు అక్కడ నవీకరించుట అమలు.

51
00:03:07,710 --> 00:03:14,360
అన్ని కుడి. మేము అక్షరాలు వ్యవహరించే మరియు మారుతున్న, విషయాలు enciphering, మీరు కనుక నుండి

52
00:03:14,360 --> 00:03:20,410
మేము నిజంగా మా ASCII పట్టిక మంచి స్నేహితులు కోరిక చూడాలని.

53
00:03:20,410 --> 00:03:24,350
మీరు భావిస్తే అనేక వాటిని, ఆన్లైన్ ఉన్నాయి. బహుశా మీ స్వంత తయారు కూడా.

54
00:03:24,350 --> 00:03:29,950
సాధారణంగా, ప్రతి అక్షరం ప్రతి సంఖ్య ప్రతి పాత్ర

55
00:03:29,950 --> 00:03:32,210
వాటికి సంబంధించిన అనేక ఉంది

56
00:03:32,210 --> 00:03:38,670
మరియు కనుక ఇది వాస్తవ లేఖ పాటు వారి ASCII విలువలు చూడటానికి బావుంటుంది.

57
00:03:38,670 --> 00:03:42,310
ఆ ఖచ్చితంగా సమస్య సెట్ లో మీరు సహాయం చేస్తుంది.

58
00:03:42,310 --> 00:03:45,750
నిజంగా ఈ సమస్య సెట్ లో నన్ను సాయపడింది ఒక విషయం, వాస్తవానికి అది ముద్రించాలా ఉంది

59
00:03:45,750 --> 00:03:48,380
నేను ద్వారా వెళుతున్నానని మరియు, నిజానికి, ఇది అందుకున్నాయి

60
00:03:48,380 --> 00:03:51,150
, రాయడానికి "ఈ అక్కడ వెళ్ళడానికి కలిగి ఉంటే, అప్పుడు ..."

61
00:03:51,150 --> 00:03:55,270
యొక్క విధమైన తీసుకుంటారు మరియు మార్కప్, మీ ASCII పట్టిక తో మంచి స్నేహితులవుతారు.

62
00:03:57,240 --> 00:04:00,750
అప్పుడు మేము మా పారవేయడం వద్ద కొన్ని ఇతర పరికరాలను కలిగి.

63
00:04:00,750 --> 00:04:03,750
ఈ సమయంలో బదులుగా వాస్తవానికి వారి ఇన్పుట్ అన్ని యూజర్ ప్రాంప్ట్

64
00:04:03,750 --> 00:04:05,230
మేము కలయిక చేయబోతున్నామని.

65
00:04:05,230 --> 00:04:06,880
మేము కొన్ని ఇన్పుట్ కోసం ప్రాంప్ట్ చూడాలని

66
00:04:06,880 --> 00:04:11,350
కానీ మేము కూడా కేవలం కమాండ్ లైన్ వాదనలు ఉపయోగించడానికి వెళుతున్న.

67
00:04:11,350 --> 00:04:15,600
కాబట్టి వారు తమ అమలు చేసేటప్పుడు, సాధారణంగా మీరు చెప్పారు. / హలో, ఉదాహరణకు,

68
00:04:15,600 --> 00:04:17,310
మీ ప్రోగ్రామ్ hello.c ఉంటే.

69
00:04:17,310 --> 00:04:22,500
కానీ ఈ సమయంలో బదులుగా కేవలం చెప్పి, తర్వాత వారు పదాలు, వాదనలు ఉంచవచ్చు.

70
00:04:22,500 --> 00:04:27,210
వారు కూడా వారి ఇన్పుట్ వంటి మాకు లో పాస్ ఏ కాబట్టి మేము ఉపయోగించడానికి వెళుతున్న

71
00:04:27,210 --> 00:04:31,720
కాబట్టి కేవలం పూర్ణాంక కోసం ప్రాంప్ట్ మించి కదిలే కానీ కమాండ్ లైన్ వాదనలను ఉపయోగించి.

72
00:04:31,720 --> 00:04:36,590
మరియు తర్వాత మేము అలాగే చాలా ఉపయోగించి వస్తుంది ఇది శ్రేణుల మరియు తీగలు లోకి తీసుకెళ్తుంది.

73
00:04:41,460 --> 00:04:44,810
ఇక్కడ 1 మినీ ASCII చార్ట్ కేవలం ఉదాహరణకు.

74
00:04:44,810 --> 00:04:48,460
నేను అన్నాడు, ప్రతి అక్షరం అనేక అనుగుణంగా

75
00:04:48,460 --> 00:04:52,510
అందువలన, అంతటమీరే సుపరిచితులు. ఇది ఉపయోగకరంగా ఉండగలదో.

76
00:04:52,510 --> 00:04:55,610
మరియు తరువాత మేము సంఖ్యలు వ్యవహరించే కొన్ని ASCIIMath చేయడం ప్రారంభించినప్పుడు -

77
00:04:55,610 --> 00:05:00,110
వాటిని తీసివేయడం, జోడించడం - ఈ పట్టికను సూచిస్తున్నారు అప్పుడు ఖచ్చితంగా మంచి.

78
00:05:02,860 --> 00:05:06,920
మీరు ఆడి అని ఏదో - ఇక్కడ ఒక సీజర్ సాంకేతికలిపి యొక్క ఉదాహరణకు.

79
00:05:06,920 --> 00:05:11,190
ఇది కేవలం ఒక వీల్ ఉంది. ముఖ్యముగా, ఒక బాహ్య వర్ణమాల ఉంది మరియు తర్వాత ఒక అంతర్గత వర్ణమాల ఉంది.

80
00:05:11,190 --> 00:05:15,290
కాబట్టి ఇక్కడే సీజర్ సాంకేతికలిపి యొక్క కాని 0 కీలక ఒక ఉదాహరణ.

81
00:05:15,290 --> 00:05:21,540
Z. వరకు సాధారణంగా, ఒక భావానికి, B B భావానికి, అన్ని మార్గం

82
00:05:21,540 --> 00:05:26,590
కానీ మేము ఉదాహరణకు, 3 యొక్క ఒక కీ కోరుకున్నారు చెప్పారు.

83
00:05:26,590 --> 00:05:33,280
ఒక ఇప్పుడు D, తదితర సర్దుబాటు తద్వారా అప్పుడు లోపలి చక్రం తిప్పడానికి చేస్తుంది

84
00:05:33,280 --> 00:05:35,250
కాబట్టి ఈ మేము చేయబోతున్నామని ఏమి తప్పనిసరిగా ఉంది.

85
00:05:35,250 --> 00:05:38,340
మేము ఒక వీల్ లేదు, కానీ మేము చేయబోతున్నామని మా కార్యక్రమం తయారు ఉంది

86
00:05:38,340 --> 00:05:44,490
రకం సంఖ్యల కొంత మాకు పాటు వర్ణమాల ఉంచారు.

87
00:05:44,490 --> 00:05:48,650
నేను ముందు చెప్పారు కనుక, మేము ఆదేశ పంక్తి వాదనలు వ్యవహరించే కావడం చేస్తున్నారు

88
00:05:48,650 --> 00:05:50,390
అలాగే పూర్ణాంకం పొందడం వంటివి.

89
00:05:50,390 --> 00:05:55,050
కాబట్టి ఒక వినియోగదారు మీ సీజర్ అమలు చేసే విధంగా విధంగా ఉంది. / సీజర్

90
00:05:55,050 --> 00:05:58,090
మరియు ఆ తర్వాత అనేక ఎంటర్.

91
00:05:58,090 --> 00:06:01,130
మరియు ఆ సంఖ్య కీ, షిఫ్ట్, సూచిస్తుంది

92
00:06:01,130 --> 00:06:06,740
ఎన్ని మీ సీజర్ సాంకేతికలిపి యొక్క అంతర్గత వీల్ తిరిగే కావడం చేసిన టైమ్స్.

93
00:06:06,740 --> 00:06:08,390
మరియు మీరు ఇక్కడ ఒక ఉదాహరణ చూడండి.

94
00:06:08,390 --> 00:06:14,550
మేము, మా సీజర్ సాంకేతికలిపి లో కి L నుండి అక్షరాలు ఎంటర్ ఉంటే

95
00:06:14,550 --> 00:06:19,520
అప్పుడు, O ద్వారా ఇన్పుట్ D ఆ 3 సార్లు మారింది ప్రతి అక్షరం ఎందుకంటే ఆ

96
00:06:19,520 --> 00:06:22,080
కేవలం నేను మీరు చూపించారు చక్రం యొక్క ఉదాహరణ ఇష్టపడుతున్నారు.

97
00:06:22,080 --> 00:06:25,300
కాబట్టి మీరు ఎంటర్ చేస్తే, ఉదాహరణకు, ఈ CS50 ఉంది!

98
00:06:25,300 --> 00:06:27,960
అప్పుడు కూడా అక్షరాలు అన్ని కదులుతారు.

99
00:06:27,960 --> 00:06:31,040
మరియు ఆ సీజర్ మరియు విజెనెరే రెండు ముఖ్యమైన విషయం

100
00:06:31,040 --> 00:06:34,890
మేము ఏ కాని అక్షరాలు మీద skip చూడాలని ఉంది.

101
00:06:34,890 --> 00:06:39,160
కాబట్టి ఏ ప్రదేశాలు, అక్షరాలు, etc, సంఖ్యలు, మేము వాటిని అదే ఉంచడానికి వెళుతున్న.

102
00:06:39,160 --> 00:06:42,920
మేము ఈ సందర్భంలో అక్షరాలు మార్చేందుకు వెళుతున్న.

103
00:06:42,920 --> 00:06:45,870
మీరు చక్రం లో చూడండి కనుక, మేము మాత్రమే, మాకు అందుబాటులో అక్షరాలు కలిగి

104
00:06:45,870 --> 00:06:50,150
కాబట్టి మేము కేవలం అక్షరాలు బదిలీ మరియు అక్షరాలు గుప్తీకరించడానికి మీరు.

105
00:06:51,370 --> 00:06:56,720
ఇది మొదటి విషయం, మీరు సమస్య లో సీజర్ కోసం వినియోగ 2 సెట్ గమనించాను

106
00:06:56,720 --> 00:07:05,280
మీరు టెర్మినల్ లో అమలు చేసినప్పుడు సీజర్ అమలు మరియు తరువాత అనేక ఎంటర్ ఉంది.

107
00:07:05,280 --> 00:07:10,940
కాబట్టి మనం ఏమి చేయాలి ఏదో ఆ గెట్ కీ మరియు యాక్సెస్ ఉంటుంది.

108
00:07:10,940 --> 00:07:14,730
కాబట్టి మేము ఏదో అది రెండవ కమాండ్ లైన్ వాదన చేస్తాడు చూడాలనుకుంటే.

109
00:07:14,730 --> 00:07:20,950
మొదటి ఒకటి. / సీజర్ ఉండబోతుంది, మరియు తరువాత ఒక కీ సంఖ్య అన్నారు.

110
00:07:22,190 --> 00:07:29,200
మేము మా సి కార్యక్రమాలు ప్రారంభించడానికి Int ప్రధాన (తప్ప) వచ్చింది. కాబట్టి ముందు

111
00:07:29,200 --> 00:07:31,790
మేము తిరిగి చర్మము ఒక పొర కొద్దిగా చూడాలని

112
00:07:31,790 --> 00:07:34,720
మరియు వాస్తవానికి చూసే బదులు మా ప్రధాన కు శూన్యంలో తరలింపు

113
00:07:34,720 --> 00:07:37,920
మేము నిజంగా 2 పారామితులు వ్యవహరించే చేస్తున్నారు.

114
00:07:37,920 --> 00:07:44,070
మేము argc అనే ఒక Int కలిగి ఆపై తీగలను యొక్క వ్యూహం argv అని.

115
00:07:44,070 --> 00:07:46,030
కాబట్టి argc, ఒక పూర్ణ సంఖ్య

116
00:07:46,030 --> 00:07:49,640
మరియు మీ ప్రోగ్రామ్ లో ఆమోదం వాదనలు సంఖ్య సూచిస్తుంది.

117
00:07:49,640 --> 00:07:53,590
ఆపై argv వాస్తవానికి జారీ వాదనలు జాబితా ఉంది.

118
00:07:53,590 --> 00:08:00,820
వాదనలు అన్ని స్ట్రింగ్స్, మరియు అందువల్ల argv తీగలను ఒక వరుస జాబితా, సూచిస్తుంది.

119
00:08:01,830 --> 00:08:03,990
యొక్క శ్రేణుల కొద్దిగా గురించి మాట్లాడేందుకు లెట్.

120
00:08:03,990 --> 00:08:05,940
వ్యూహాలను కూడా కావాలంటే ఒక కొత్త డేటా నిర్మాణం ఉన్నాయి.

121
00:08:05,940 --> 00:08:09,660
మేము, మేము డబుల్స్ చేశారు, ints మేము తీగలను కలిగి, మరియు ఇప్పుడు మేము శ్రేణుల ఉన్నాయి.

122
00:08:09,660 --> 00:08:13,820
వ్యూహాలను, ఒకే రకమైన అనేక విలువలు కలిగి ఆ డేటా కట్టడాలు

123
00:08:13,820 --> 00:08:18,320
కాబట్టి ముఖ్యంగా, మీరు కావలసిన రకం జాబితా.

124
00:08:18,320 --> 00:08:24,400
ముఖ్యంగా, మీరు అన్ని 1 వేరియబుల్ పూర్ణాంకాల యొక్క జాబితా కోరుకుంటే,

125
00:08:24,400 --> 00:08:29,090
అప్పుడు మీరు టైప్ Int శ్రేణి యొక్క అని ఒక కొత్త కారకం సృష్టిస్తుంది.

126
00:08:29,090 --> 00:08:34,450
కాబట్టి శ్రేణుల శ్రేణి యొక్క మొదటి మూలకం సూచిక 0 వద్ద అని అర్థం, సున్నా-వర్గీకరించబడతాయి.

127
00:08:34,450 --> 00:08:41,799
అర్రే ఈ ఉదాహరణలో వంటి పొడవు 4, యొక్క ఉంటే, అప్పుడు మీ చివరి మూలకం, ఇండెక్స్ 3 వద్ద ఉంటుంది

128
00:08:41,799 --> 00:08:44,810
1 - 4 ఉంటుంది.

129
00:08:45,940 --> 00:08:48,420
కాబట్టి శ్రేణి సృష్టించడానికి, మీరు ఈ వంటి ఏదో ఒకటి ఉంటుంది.

130
00:08:48,420 --> 00:08:51,440
మీరు ఒక డబుల్ శ్రేణి కోరుకున్నారు సే.

131
00:08:51,440 --> 00:08:56,520
ఈ అయితే, డేటా రకం ఏ రకం కోసం వెళుతుంది.

132
00:08:56,520 --> 00:09:00,210
మీరు ఒక డబుల్ శ్రేణి కావలసిన చెప్పడానికి. మీరు మెయిల్ బాక్స్ కాల్ అనుకుందాం.

133
00:09:00,210 --> 00:09:04,760
మీరు ఏ ఇతర డబుల్ ప్రారంభించడం ఉంటుంది వలె,

134
00:09:04,760 --> 00:09:09,760
, మీరు డబుల్ ఆపై పేరు చెబుతారు, కానీ ఈ సమయంలో చదరపు బ్రాకెట్లలో మేము ఉంచండి

135
00:09:09,760 --> 00:09:13,570
ఆపై సంఖ్య శ్రేణి పొడవు ఉంటుంది.

136
00:09:13,570 --> 00:09:16,840
శ్రేణుల లో మనం పొడవు మార్చలేరు గమనించండి,

137
00:09:16,840 --> 00:09:21,230
మీరు ఎల్లప్పుడూ, ఎన్ని పెట్టెలు నిర్వచించే మరియు ఎంచుకోవడానికి కలిగి

138
00:09:21,230 --> 00:09:25,440
ఎన్ని విలువలు మీ శ్రేణి కలిగి అన్నారు.

139
00:09:25,440 --> 00:09:31,820
మీ శ్రేణి వివిధ విలువల సెట్, మీరు, ఈ క్రింది సింటెక్స్ ఉపయోగించడానికి వెళుతున్న

140
00:09:31,820 --> 00:09:33,200
మీరు స్లయిడ్ న చూడుము.

141
00:09:33,200 --> 00:09:37,620
మీకు మెయిల్ బాక్స్ సూచిక 0, 1.2 అమర్చబడుతుంది

142
00:09:37,620 --> 00:09:42,180
2.4 మెయిల్బాక్స్ సూచిక 1 సెట్ మొదలైనవి

143
00:09:42,180 --> 00:09:47,910
కాబట్టి ఇప్పుడు మేము శ్రేణుల ఒక బిట్ సమీక్షించారు చేసారు, యొక్క argc మరియు argv తిరిగి వదలి వేస్తారు.

144
00:09:47,910 --> 00:09:52,220
మేము ఇప్పుడు argv తీగలను యొక్క వ్యూహం అని తెలుసు.

145
00:09:52,220 --> 00:09:55,080
కాబట్టి ఒక వినియోగదారు లో పోయినప్పుడు - వారు ఒక ప్రోగ్రామ్ను అమలు చేస్తున్నారు అనుకోండి -

146
00:09:55,080 --> 00:09:58,740
వారు చెప్పేది. / హలో డేవిడ్ మలన్,

147
00:09:58,740 --> 00:10:05,160
మీరు ఇప్పటికే వాస్తవానికి argc మరియు argv ఏమిటో ఆలోచన ఉంది కోసం ప్రోగ్రామ్ ఏమి కనిపిస్తుంది.

148
00:10:05,160 --> 00:10:07,620
కాబట్టి దాని గురించి ఆందోళన అవసరం లేదు.

149
00:10:07,620 --> 00:10:14,370
అది ఖాళీలతో వేరు 3 విభిన్న పదాలను చూస్తారు ఎందుకంటే ఈ సందర్భంలో Argc 3 ఉంటుంది.

150
00:10:14,370 --> 00:10:18,850
కాబట్టి ఈ సందర్భంలో అర్రే, మొదటి సూచిక ఉంటుంది. / హలో,

151
00:10:18,850 --> 00:10:21,770
తదుపరి డేవిడ్, తర్వాత ఒక మలన్.

152
00:10:21,770 --> 00:10:25,640
ఎవరైనా, argv మధ్య ఏ సంబంధం వెంటనే చూడండి లేదు

153
00:10:25,640 --> 00:10:28,990
 అర్రే, మరియు argc ఉంది?

154
00:10:32,820 --> 00:10:38,090
అవును. మేము args.c. ఒక ఉదాహరణ ఆ లోకి పొందుతారు

155
00:10:38,090 --> 00:10:42,880
మేము 2 మధ్య సంబంధం యొక్క ప్రయోజనాన్ని లేదో యొక్క చూసేలా.

156
00:10:42,880 --> 00:10:46,550
ఇక్కడ మీరు పరికరంలోని ఆ కలిగించే డిఫాల్ట్ అప్లికేషన్

157
00:10:46,550 --> 00:10:49,450
. సి ఫైళ్ళను తెరవడానికి కొన్నిసార్లు Emacs ఉంది.

158
00:10:49,450 --> 00:10:54,660
కానీ మేము gedit వ్యవహరించే మీరు, మీరు ఏమి మీరు మీ సి ఫైలు క్లిక్ చెయ్యండి కనుక

159
00:10:54,660 --> 00:11:04,580
దీనితో తెరువు, ప్రాపర్టీస్ వెళ్లి, డిఫాల్ట్ లా సెట్ చెయ్యండి gedit, ఎంచుకోండి

160
00:11:04,580 --> 00:11:13,020
మరియు ఇప్పుడు మీ ప్రోగ్రామ్ gedit బదులుగా Emacs ప్రారంభం అవ్వాలి.

161
00:11:14,710 --> 00:11:16,290
పర్ఫెక్ట్.

162
00:11:17,120 --> 00:11:25,520
ఇక్కడ నేను ప్రతి కమాండ్ లైన్ ఆర్గ్యుమెంట్ ముద్రించడానికి కావలసిన ఒక ప్రోగ్రామ్ను.

163
00:11:25,520 --> 00:11:32,050
ఏ యూజర్ ఇన్పుట్లను కాబట్టి, నేను తప్పనిసరిగా కొత్త లైన్ వాటిని తిరిగి తిరిగి అనుకుంటున్నారా.

164
00:11:32,050 --> 00:11:36,710
కాబట్టి మేము ఏదో పైగా iterate ఉపయోగించే ఒక నిర్మాణం ఏది -

165
00:11:36,710 --> 00:11:40,380
మీరు బహుశా మీ pset 1 లో ఉపయోగించిన ఏదో?

166
00:11:40,380 --> 00:11:45,840
మీరు విషయాలను సెట్ సంఖ్య ద్వారా వెళ్లాలనుకుంటున్నారా? ఉంటే >> లూప్ [విద్యార్థి].

167
00:11:45,840 --> 00:11:48,910
లూప్. సరిగ్గా. కాబట్టి లూప్ తో ప్రారంభిద్దాం.

168
00:11:48,910 --> 00:11:56,900
మేము Int i = 0 ఉన్నది. లెట్ యొక్క కేవలం ప్రామాణిక ప్రారంభ వేరియబుల్ ప్రారంభం.

169
00:11:56,900 --> 00:12:02,370
నేను ఒక సెట్ కోసం పరిస్థితి వదిలి నేను + +, అక్కడ పనులు వెళ్లి చెప్పే వెళుతున్న.

170
00:12:02,370 --> 00:12:04,090
అన్ని కుడి.

171
00:12:04,090 --> 00:12:11,590
కాబట్టి argv కార్యక్రమానికి జారీ వాదనలు జాబితా ఉంది, argv తిరిగి ఆలోచించడం

172
00:12:11,590 --> 00:12:15,380
మరియు argc, కార్యక్రమంలో వాదనలు సంఖ్య

173
00:12:15,380 --> 00:12:21,280
ఆ argc argv ముఖ్యమైన పొడవు, కుడి, అర్థం

174
00:12:21,280 --> 00:12:28,970
argc యొక్క విలువ చాలా వాదనలు ఉన్నట్లు వెళ్తున్నారు ఎందుకంటే.

175
00:12:28,970 --> 00:12:35,910
మేము, argv ప్రతి మూలకం పైగా iterate మీరు అనుకుంటే

176
00:12:35,910 --> 00:12:43,290
మేము ప్రతి సమయం సూచిక వద్ద argv లో వేరియబుల్ యాక్సెస్ కావలసిన చూడాలని.

177
00:12:43,290 --> 00:12:49,060
కుడివైపు, ఈ తో ప్రాతినిధ్యం చేయవచ్చు?

178
00:12:49,060 --> 00:12:53,430
ఇక్కడ ఈ వేరియబుల్ ఈ సందర్భంలో ప్రత్యేకంగా తంతి సూచిస్తుంది

179
00:12:53,430 --> 00:12:57,030
ఎందుకంటే అది ఒక స్ట్రింగ్ శ్రేణి ఉంది - ఆ సూచిక వద్ద ప్రత్యేక స్ట్రింగ్.

180
00:12:57,030 --> 00:13:00,690
మేము మీరు ఏమి, ఈ విషయంలో మేము దాన్ని ముద్రించడానికి కావాలి, కాబట్టి printf సే తెలియజేయండి.

181
00:13:00,690 --> 00:13:04,680
ఇప్పుడు argv స్ట్రింగ్, కాబట్టి మేము అక్కడ ఆ ప్లేస్హోల్డర్ ఉంచాలి కావలసిన.

182
00:13:04,680 --> 00:13:08,430
మేము దానిని అందంగా కనిపించేలా ఒక కొత్త లైన్ కావలసిన.

183
00:13:08,430 --> 00:13:12,530
ఇక్కడ మేము ఒక కోసం లూప్ ఉన్నాయి. మేము ఇంకా పరిస్థితి లేదు.

184
00:13:12,530 --> 00:13:20,020
నేను ఇచ్చిన స్ట్రింగ్ ముద్రించడానికి జరగబోతోంది ప్రతిసారీ అప్పుడు 0 మొదలవుతుంది మరియు

185
00:13:20,020 --> 00:13:22,980
అర్రే లో నిర్దిష్ట సూచిక వద్ద.

186
00:13:22,980 --> 00:13:28,410
కాబట్టి మేము యెరే నందలి అంశాలు ముద్రించిన ఆపివేయాలనుకుంటున్నారా లేనప్పుడు?

187
00:13:28,410 --> 00:13:35,720
మేము పూర్తి చేసిన తర్వాత, కుడి? మేము శ్రేణి ముగింపు చేరుకున్నారు ఉన్నప్పుడు.

188
00:13:35,720 --> 00:13:38,870
కాబట్టి మేము, అర్రే యొక్క పొడవు గత దాటి చేయకూడదని

189
00:13:38,870 --> 00:13:43,700
మరియు మేము ఇప్పటికే మేము నిజంగా చురుకుగా argv యొక్క పొడవు ఎంత కనుగొనేందుకు అవసరం లేదు తెలుసు

190
00:13:43,700 --> 00:13:47,520
ఎందుకంటే అది మాకు ఇచ్చిన, మరియు ఆ ఏది యొక్క? Argc. సరిగ్గా.

191
00:13:47,520 --> 00:13:56,640
కాబట్టి మేము సార్లు ఈ ప్రక్రియ argc సంఖ్య చేయాలనుకుంటున్నారా.

192
00:13:56,640 --> 00:13:59,550
నేను డైరెక్టరీ కాదు.

193
00:14:02,100 --> 00:14:03,490
అన్ని కుడి.

194
00:14:03,490 --> 00:14:08,990
ఇప్పుడు ARGS తయారు చేద్దాము. గొప్ప ఇది లోపాలు.

195
00:14:08,990 --> 00:14:11,430
కాబట్టి యొక్క కేవలం ARGS అమలు అనుమతిస్తాయి.

196
00:14:11,430 --> 00:14:15,130
ఈ మాకు తిరిగి ఏమి జరుగుతుందో? ఇది కేవలం అది తిరిగి ముద్రించడం జరగబోతోంది.

197
00:14:15,130 --> 00:14:18,320
"మీరు కార్యక్రమంలోకి ARGS ఇన్పుట్; నేను మీకు తిరిగి ఇవ్వాలని వెళుతున్న."

198
00:14:18,320 --> 00:14:23,170
కాబట్టి లెట్స్ మేము అప్పుడు foo బార్ ARGS చెప్పడానికి అనుకుందాం.

199
00:14:23,170 --> 00:14:26,570
కాబట్టి అప్పుడు మాకు తిరిగి దాన్ని ముద్రిస్తుంది. అన్ని కుడి?

200
00:14:26,570 --> 00:14:30,790
కాబట్టి మీరు argc మరియు argv ఉపయోగించవచ్చు ఎలా ఒక ఉదాహరణ ఉంది

201
00:14:30,790 --> 00:14:33,460
ఆ argc తెలుసుకోవడం argv యొక్క పొడవు సూచిస్తుంది.

202
00:14:33,460 --> 00:14:42,750
మీరు శ్రేణి పొడవు మించి శ్రేణుల యాక్సెస్ ఒక తో ఎప్పుడూ లేదు నిర్ధారించుకోండి

203
00:14:42,750 --> 00:14:45,140
సి ఖచ్చితంగా మీరు వద్ద అరవండి ఎందుకంటే.

204
00:14:45,140 --> 00:14:47,560
మీరు, విభజన లోపంగా అనే పొందుతారు

205
00:14:47,560 --> 00:14:52,470
ఇది ప్రాథమికంగా మీరు ఏదో ప్రాప్తి చేయడానికి ప్రయత్నిస్తున్న చెప్పడం, సరదాగా ఎన్నటికీ

206
00:14:52,470 --> 00:14:55,000
లేదు, మీరు చెందినది కాదు.

207
00:14:55,000 --> 00:14:59,430
కాబట్టి నిర్ధారించుకోండి, మరియు ముఖ్యంగా సున్నా-ఇండెక్సింగ్ తో, మేము అనుకుంటున్న -

208
00:14:59,430 --> 00:15:02,390
మేము పొడవు 4 యొక్క వ్యూహం ఉంటే, ఉదాహరణకు ఇష్టం

209
00:15:02,390 --> 00:15:07,240
మేము సున్నా సూచిక వద్ద, 0 వద్ద మొదలు ఎందుకంటే ఆ అర్రే సూచిక 4 లేదు.

210
00:15:07,240 --> 00:15:11,730
మేము 0 వద్ద ప్రారంభించిన ఇది ఉచ్చులు కోసం వంటి రెండవ ప్రకృతి అవుతుంది.

211
00:15:11,730 --> 00:15:13,610
కాబట్టి కేవలం గుర్తుంచుకోండి.

212
00:15:13,610 --> 00:15:22,590
మీరు ఎప్పుడూ మీ అంచనాలను మించి ఆ వ్యూహం యొక్క ఇండెక్స్ ప్రాప్తి చేయడానికి ఇష్టం లేదు.

213
00:15:26,710 --> 00:15:32,560
కాబట్టి మేము ఎలా మేము ఆక్సెస్ రకం ఇప్పుడు చూడగలరు

214
00:15:32,560 --> 00:15:35,930
సైన్ జారీ ఆ ఆదేశ పంక్తి వాదనలు

215
00:15:35,930 --> 00:15:41,330
మీరు స్ట్రింగ్ చూసిన కానీ, argv అసలైన స్ట్రింగ్ శ్రేణి.

216
00:15:41,330 --> 00:15:45,740
కాబట్టి అది ఇంకా నిజానికి ఒక పూర్ణాంకం కాదు, అయితే సీజర్ లో మనం పూర్ణాంకం వ్యవహరించే మీరు.

217
00:15:45,740 --> 00:15:54,430
అదృష్టవశాత్తు, వాస్తవానికి పూర్ణాంకం ఒక స్ట్రింగ్ మార్చవచ్చు మాకు రూపొందించినవారు ఒక ఫంక్షన్ ఉంది.

218
00:15:54,430 --> 00:15:58,710
మేము వాటిని ప్రోత్సహించే ఎక్కడ కూడా ఇక్కడ మేము వినియోగదారు ఇన్పుట్ వ్యవహరించే లేదు

219
00:15:58,710 --> 00:16:03,740
కీ కోసం ఇక్కడ ఇన్పుట్ కోసం, కాబట్టి మేము నిజానికి, reprompt మరియు చెప్పలేను

220
00:16:03,740 --> 00:16:07,840
"అది చెల్లదు అయితే ఓహ్, సే,, నాకు మరొక పూర్ణాంకం ఇస్తాయి."

221
00:16:07,840 --> 00:16:10,540
కానీ మేము ఇంకా సరైన వాడుక తనిఖీ చేయాలి.

222
00:16:10,540 --> 00:16:13,520
సీజర్ వారు మాత్రమే, 1 సంఖ్య పాస్ అనుమతించబడతాయి

223
00:16:13,520 --> 00:16:18,030
అందువలన వారు. / సీజర్ అమలు చేసి తర్వాత వారు మీరు అనేక ఇవ్వాల్సి ఉంటుంది.

224
00:16:18,030 --> 00:16:23,660
కాబట్టి argc ఒక నిర్దిష్ట సంఖ్యలో ఉండాలి.

225
00:16:23,660 --> 00:16:29,060
వారు మీరు. / సీజర్ మరియు తరువాత కీ పాస్ కలిగి ఉంటే సంఖ్య ఉంటుంది?

226
00:16:29,060 --> 00:16:32,920
Argc ఏమిటి? >> [విద్యార్థి] 2. >> రెండు. సరిగ్గా.

227
00:16:32,920 --> 00:16:35,490
కాబట్టి మీరు argc 2 నిర్ధారించుకోవాలి.

228
00:16:35,490 --> 00:16:39,620
లేకపోతే మీరు ప్రధానంగా ప్రోగ్రామ్ను అమలు చేయడానికి నిరాకరిస్తుంది.

229
00:16:39,620 --> 00:16:43,040
ప్రధాన ఇది, Int ప్రధాన అని ఒక ఫంక్షన్ ఉంది

230
00:16:43,040 --> 00:16:47,360
కాబట్టి అప్పుడు విజయవంతమైన ప్రోగ్రామ్ చివరిలో మంచి పద్ధతి తిరిగి 0 లో ఎప్పుడూ మేము.

231
00:16:47,360 --> 00:16:50,840
సే, చేస్తే, వారు మీరు 3 ఆదేశ పంక్తి వాదనలు బదులుగా 2 ఇవ్వాలని

232
00:16:50,840 --> 00:16:54,350
లేదా మీరు ఆ కోసం తనిఖీ చెయ్యవచ్చును మీరు ఏమి చేస్తాము ఉంది అప్పుడు, ఉదాహరణకు, మీరు 1 ఇవ్వాలని

233
00:16:54,350 --> 00:16:59,900
మరియు తర్వాత ఏ విధంగా 1 తిరిగి, నేను ఈ కార్యక్రమం కొనసాగలేము.

234
00:16:59,900 --> 00:17:03,190
[విద్యార్థి] ఉన్నాయి మీ టెక్స్ట్ లో ఒక స్పేస్ ఉండకూడదు. >> నాకు క్షమించండి?

235
00:17:03,190 --> 00:17:06,780
[విద్యార్థి] మీరు గుప్తీకరించడానికి ప్రయత్నిస్తున్న టెక్స్ట్ లో ఒక స్పేస్ ఉండదు.

236
00:17:06,780 --> 00:17:08,480
ఆహ్!

237
00:17:08,480 --> 00:17:11,280
మేము గుప్తీకరించడానికి ప్రయత్నిస్తున్న టెక్స్ట్ పరంగా, వాస్తవానికి తరువాత వస్తుంది

238
00:17:11,280 --> 00:17:13,970
మేము టెక్స్ట్ అందచేసినప్పుడు.

239
00:17:13,970 --> 00:17:18,260
కాబట్టి ఇప్పుడు మేము వాస్తవ సంఖ్య, ఆదేశం వాదనలు అంగీకరించడం చేస్తున్నారు

240
00:17:18,260 --> 00:17:21,579
సీజర్ ఎన్క్రిప్షన్ కోసం నిజమైన మార్పు.

241
00:17:21,579 --> 00:17:27,569
[విద్యార్థి] కేవలం 1 argc వ్యతిరేకంగా ఎందుకు మీరు 2 చేయాలి? 1 సంఖ్య ఖచ్చితంగా ఉంది.

242
00:17:27,569 --> 00:17:32,200
కుడి. మేము argc 2 అవసరం కారణం బదులుగా 1

243
00:17:32,200 --> 00:17:36,260
మీరు ఒక ప్రోగ్రామ్ రన్ మరియు చెప్పినప్పుడు మీరు ఎందుకంటే ఉంది. / సీజర్ లేదా. / హలో,

244
00:17:36,260 --> 00:17:38,280
వాస్తవానికి ఒక కమాండ్ లైన్ వాదన గా లెక్కింపబడుతుంది.

245
00:17:38,280 --> 00:17:43,020
కాబట్టి ఆ ఇప్పటికే 1 తీసుకుంటుంది మరియు అందువలన మేము 1 అదనపు ఇవ్వడం చేస్తున్నారు.

246
00:17:45,030 --> 00:17:49,440
కాబట్టి మీరు నిజంగా కమాండ్ లైన్ వాదన లో స్ట్రింగ్ ఇవ్వడం చేస్తున్నారు.

247
00:17:49,440 --> 00:17:52,730
మీరు మీరు ఏమి, సీజర్ కోసం మేము, ఒక పూర్ణాంకం వ్యవహరించే మీరు

248
00:17:52,730 --> 00:17:57,180
కాబట్టి మీరు ఈ atoi క్రియాశీలతను ఉపయోగించగలదు.

249
00:17:57,180 --> 00:18:02,850
మరియు ప్రధానంగా, మీరు ఒక స్ట్రింగ్ లో పాస్ మరియు అప్పుడు పూర్ణాంకం మీరు తిరిగి తిరిగి

250
00:18:02,850 --> 00:18:06,070
అది ఒక పూర్ణాంకం ఆ స్ట్రింగ్ చేయడానికి అవకాశం ఉంటే.

251
00:18:06,070 --> 00:18:10,960
మేము వలె printf లేదా GetString విషయాలు వ్యవహరించే చేసినప్పుడు ఇప్పుడు గుర్తు

252
00:18:10,960 --> 00:18:13,390
మేము మాకు నిర్దిష్టమైన గ్రంధాలయాలు ఉన్నాయి.

253
00:18:13,390 --> 00:18:19,450
కాబట్టి ప్రారంభంలో ఆ వంటి హాష్ ట్యాగ్ ప్రామాణిక I / O,. H, ఏదో ప్రారంభం.

254
00:18:19,450 --> 00:18:22,430
Well, atoi, ఆ గ్రంథాలయాల్లో ఒకటిగా లో లేదు

255
00:18:22,430 --> 00:18:26,600
కాబట్టి మనం చేయవలసింది ఆ సరైన గ్రంధాలయం ఉన్నాయి కలిగి ఉంది.

256
00:18:26,600 --> 00:18:32,720
నేను మాన్యువల్ ఫంక్షన్ చర్చించే Walkthrough 1 తిరిగి గుర్తు.

257
00:18:32,720 --> 00:18:37,110
మీరు మీ టెర్మినల్ వ్యక్తి టైప్ చేసి, ఆపై ఒక చర్య యొక్క పేరును అనుసరిస్తూ.

258
00:18:37,110 --> 00:18:39,720
కాబట్టి, దాని ఉపయోగం యొక్క పూర్తి జాబితాను అప్ కలిగించే

259
00:18:39,720 --> 00:18:42,890
కానీ అదే ఆ చెందిన ఇది లైబ్రరీ కి తీసుకొస్తుంది.

260
00:18:42,890 --> 00:18:47,000
నేను atoi తో మాన్యువల్ ఫంక్షన్ను ఉపయోగించడానికి మీరు ఆ చెప్పను

261
00:18:47,000 --> 00:18:53,360
మరియు మీరు atoi క్రియాశీలతను ఉపయోగించదు చెయ్యడానికి ఉన్నాయి అవసరం ఇది లైబ్రరీని చూడవచ్చు.

262
00:18:54,450 --> 00:18:57,670
, కాబట్టి మేము కీ పొందారు మరియు ఇప్పుడు అది సాదా టెక్స్ట్ పొందడానికి వస్తుంది

263
00:18:57,670 --> 00:19:01,820
అందువలన వాస్తవంగా మిమ్ములను పేరు వినియోగదారు ఇన్పుట్ మాత్రం ఆ.

264
00:19:01,820 --> 00:19:05,540
మేము అదే పంథాలో కాబట్టి GetInt మరియు GetFloat నిర్వహించాయి, మరియు

265
00:19:05,540 --> 00:19:07,670
మేము GetString వ్యవహరించే కావడం చేస్తున్నారు.

266
00:19:07,670 --> 00:19:12,440
అయితే లేదా ఉచ్చులు తనిఖీ కానీ ఈ విషయంలో మేము ఏ చేస్తారా లేదు.

267
00:19:12,440 --> 00:19:14,480
GetString ఖచ్చితంగా, మాకు ఒక స్ట్రింగ్ ఇస్తుంది

268
00:19:14,480 --> 00:19:17,630
మరియు మేము వినియోగదారు మాకు ఇస్తుంది ఏ గుప్తీకరించడానికి వెళుతున్న.

269
00:19:17,630 --> 00:19:23,770
మీరు ఈ యూజర్ ఇన్పుట్ చేసిన తీగలను అన్ని సరైనవని పొందవచ్చు.

270
00:19:23,770 --> 00:19:24,670
గ్రేట్.

271
00:19:24,670 --> 00:19:27,270
, కాబట్టి అప్పుడు మీరు కీ పొందారు మరియు ఒకసారి మీరు టెక్స్ట్ పొందారు

272
00:19:27,270 --> 00:19:31,660
ఇప్పుడు ఎడమ ఏమి మీరు సాదా encipher ఉంటుంది ఉంది.

273
00:19:31,660 --> 00:19:36,530
జస్ట్ త్వరగా లింగో పైగా కవర్ చేయడానికి, సాదా, యూజర్ మీరు లభిస్తుంది

274
00:19:36,530 --> 00:19:41,030
మరియు సాంకేతికలిపి మీరు వాటిని తిరిగి ఏమిటి.

275
00:19:42,450 --> 00:19:45,850
తీగలను కాబట్టి, లేఖ ద్వారా వాస్తవానికి లేఖ ద్వారా వెళ్ళి చెయ్యడానికి

276
00:19:45,850 --> 00:19:48,550
మేము ప్రతి అక్షరం మార్చేందుకు ఎందుకంటే,

277
00:19:48,550 --> 00:19:51,390
మేము ఆ తీగలను అర్థం, అయితే తిరిగి పొర పీల్ మేము రకం

278
00:19:51,390 --> 00:19:54,130
మేము అవి నిజంగా అక్షరాలు జాబితా మేము చూసాము.

279
00:19:54,130 --> 00:19:55,930
ఒక ఇతర తర్వాత వస్తుంది.

280
00:19:55,930 --> 00:20:01,690
వారు అక్షరాలు వ్యూహాలను ఎందుకంటే కాబట్టి మేము శ్రేణుల వంటి తీగలను చికిత్స చేయవచ్చు.

281
00:20:01,690 --> 00:20:05,640
, మీరు టెక్స్ట్ అనే స్ట్రింగ్ కలిగి చెప్పడానికి

282
00:20:05,640 --> 00:20:09,400
మరియు ఆ వేరియబుల్ పాఠ్యమును లోపల ఈ CS50 ఉంది నిల్వ చేయబడుతుంది.

283
00:20:09,400 --> 00:20:15,680
అప్పుడు ఇండెక్స్ 0 వద్ద టెక్స్ట్ రాజధాని T ఉంటుంది, ఇండెక్స్ 1 h, మొదలైనవి ఉంటుంది

284
00:20:17,530 --> 00:20:23,970
ఆపై శ్రేణితో, args.c లో argc ఉదాహరణలో,

285
00:20:23,970 --> 00:20:27,090
మేము వ్యూహం మీద iterate వచ్చింది చూసిన

286
00:20:27,090 --> 00:20:32,440
అందువలన మేము నేను పొడవు కంటే తక్కువగా ఉంటుంది వరకు నేను = 0 అప్ iterate వచ్చింది.

287
00:20:32,440 --> 00:20:35,560
కాబట్టి మేము మా స్ట్రింగ్ యొక్క పొడవు ఎంత ఇందుకు కొన్ని మార్గం అవసరం

288
00:20:35,560 --> 00:20:37,090
మేము దాని పై iterate చూడాలని ఉంటే.

289
00:20:37,090 --> 00:20:42,300
అదృష్టవశాత్తు మళ్లీ మాకు అక్కడ ఒక ఫంక్షన్ అయితే తర్వాత CS50 లో ఉంది

290
00:20:42,300 --> 00:20:45,860
మీరు ఖచ్చితంగా మీ స్వంత ఫంక్షన్ అమలు తయారు చేయగలరు

291
00:20:45,860 --> 00:20:48,260
ఒక స్ట్రింగ్ యొక్క పొడవు లెక్కించవచ్చు.

292
00:20:48,260 --> 00:20:52,120
కానీ ఇప్పుడు కోసం మేము స్ట్రింగ్ పొడవు, కాబట్టి strlen ఉపయోగించడానికి వెళుతున్న.

293
00:20:52,120 --> 00:21:00,440
మీరు ఒక స్ట్రింగ్ లో పాస్, మరియు అప్పుడు మీరు మీ స్ట్రింగ్ యొక్క పొడవు సూచించే ఒక Int చూపిస్తుంది.

294
00:21:00,440 --> 00:21:05,840
యొక్క మేము ఒక స్ట్రింగ్ లో ప్రతి పాత్ర మీద iterate చేయగలరు ఎలా ఒక ఉదాహరణ చూద్దాం

295
00:21:05,840 --> 00:21:08,470
మరియు ఆ ఏదో ఒకటి.

296
00:21:08,470 --> 00:21:13,250
మనం చేయాలనుకుంటున్నారా, స్ట్రింగ్ యొక్క ప్రతి పాత్ర మీద iterate ఉంది

297
00:21:13,250 --> 00:21:19,150
మరియు మేము చేయాలనుకుంటున్నారా ఉంది మేము 1 ప్రతి పాత్ర 1 తిరిగి ప్రింట్

298
00:21:19,150 --> 00:21:22,060
మేము అది ప్రక్కన ఏదో జోడించడానికి తప్ప.

299
00:21:22,060 --> 00:21:27,020
కాబట్టి లూప్ తో ప్రారంభిద్దాం. Int i = 0.

300
00:21:27,020 --> 00:21:30,070
మేము పరిస్థితి స్థలాన్ని విడిచి వెళుతున్న.

301
00:21:32,700 --> 00:21:36,840
మేము స్ట్రింగ్ ముగింపు చేరుకోవడానికి వరకు, iterate మీరు కుడి?

302
00:21:36,840 --> 00:21:41,340
కాబట్టి అప్పుడు ఏమి ఫంక్షన్ మాకు స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది?

303
00:21:41,340 --> 00:21:43,160
[వినబడని విద్యార్థి ప్రతిస్పందన]

304
00:21:43,160 --> 00:21:46,420
ఆ ఆదేశ పంక్తి వాదనలు యొక్క పొడవు ఉంది.

305
00:21:46,420 --> 00:21:50,650
కానీ ఒక స్ట్రింగ్ కోసం మేము మాకు స్ట్రింగ్ యొక్క పొడవు ఇచ్చే ఫంక్షన్ ఉపయోగించాలనుకుంటున్నాను.

306
00:21:50,650 --> 00:21:53,090
కాబట్టి ఆ స్ట్రింగ్ పొడవు ఉంది.

307
00:21:53,090 --> 00:21:57,130
కాబట్టి మీకు ఒక స్ట్రింగ్ లో ఉత్తీర్ణత సాధించవలసి ఉంటుంది.

308
00:21:57,130 --> 00:21:59,760
ఇది పొడుగు గణించటం అవసరం ఏమి స్ట్రింగ్ తెలుసుకోవాలి.

309
00:21:59,760 --> 00:22:03,160
కాబట్టి ఈ విషయంలో మేము స్ట్రింగ్ s వ్యవహరించే చేస్తున్నారు.

310
00:22:04,790 --> 00:22:05,860
గ్రేట్.

311
00:22:05,860 --> 00:22:10,770
కాబట్టి అప్పుడు మేము మీరు ఏమి, యొక్క printf తెలియజేయండి.

312
00:22:10,770 --> 00:22:14,850
ఇప్పుడు మేము అక్షరాలు వ్యవహరించే మీరు. మేము ప్రతి వ్యక్తి పాత్రను ప్రింట్ మీరు.

313
00:22:14,850 --> 00:22:22,150
మీరు ఒక ఫ్లోట్ ముద్రించాలా ఉంటుంది, మీరు% F వంటి ప్లేస్హోల్డర్ ఉపయోగించారు.

314
00:22:22,150 --> 00:22:24,580
ఒక పూర్ణాంకానికి మీరు% d ను ఉపయోగించాలి.

315
00:22:24,580 --> 00:22:30,890
కాబట్టి అదే విధంగా, ఒక పాత్ర మీకు నేను ఒక పాత్ర ప్రింటింగ్ కూడా వెళుతున్న చెప్పడానికి% C ఉపయోగించండి

316
00:22:30,890 --> 00:22:34,570
ఒక వేరియబుల్ లోపల నిల్వ చెయ్యబడింది.

317
00:22:34,570 --> 00:22:40,840
కాబట్టి మేము ఈ కలిగి, మరియు ఇది ఒక కాలం మరియు ఖాళీ జోడించడానికి అనుమతిస్తుంది.

318
00:22:40,840 --> 00:22:45,430
మేము ఏ పాత్ర ఉపయోగిస్తున్నారు?

319
00:22:45,430 --> 00:22:49,780
మేము స్ట్రింగ్ యొక్క ఉన్నాము ఏ పాత్ర ఉపయోగించి చూడాలని.

320
00:22:49,780 --> 00:22:52,890
కాబట్టి అప్పుడు మేము, స్ట్రింగ్ ఏదో ఉపయోగించి చూడాలని

321
00:22:52,890 --> 00:22:56,420
కానీ మేము అక్కడ కొన్ని పాత్ర యాక్సెస్ మీరు కోరుకుంటున్నారు.

322
00:22:56,420 --> 00:23:02,740
ఒక స్ట్రింగ్ కేవలం ఒక శ్రేణి చేస్తే, అప్పుడు మేము ఎలా శ్రేణుల యొక్క అంశాలను యాక్సెస్ చేయాలి?

323
00:23:02,740 --> 00:23:06,480
మేము ఆ చదరపు బ్రాకెట్లలో కలిగి, మరియు అప్పుడు మేము అక్కడ సూచిక ఉంచండి.

324
00:23:06,480 --> 00:23:11,820
కాబట్టి మేము చదరపు బ్రాకెట్లలో ఉంది. ఈ సందర్భంలో మా ఇండెక్స్ మేము ఉపయోగించడానికి. సరిగ్గా.

325
00:23:15,290 --> 00:23:22,370
ఇక్కడ మేము, మేము ఒక డాట్ మరియు ఒక స్పేస్ ఒక పాత్ర ప్రింటింగ్ కావడం చేస్తున్న చెబుతున్న దాన్ని

326
00:23:22,370 --> 00:23:30,870
మరియు ఆ పాత్ర మా స్ట్రింగ్ s లో ith లేఖలో అన్నారు.

327
00:23:32,920 --> 00:23:39,330
నేను ఆ సేవ్ వెళుతున్న. సరే.

328
00:23:42,510 --> 00:23:46,840
ఇప్పుడు నేను స్ట్రింగ్ పొడవు అమలు వెళుతున్న.

329
00:23:46,840 --> 00:23:53,440
కాబట్టి మేము OMG అనే స్ట్రింగ్ కలిగి, మరియు ఇప్పుడు అది మరింత నొక్కి యొక్క.

330
00:23:53,440 --> 00:23:57,870
అదేవిధంగా, లెట్స్ మేము నిజంగా వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందడానికి అనుకుందాం.

331
00:23:57,870 --> 00:23:59,580
దీన్ని మేము ఎలా ఏమి ఉండవచ్చు?

332
00:23:59,580 --> 00:24:01,610
ముందు, ఎలా మేము ఒక పూర్ణాంకానికి వచ్చింది?

333
00:24:01,610 --> 00:24:08,040
మేము GetInt, కుడి చెప్పారు? కానీ ఈ Int, అందువలన GetString చూద్దాం.

334
00:24:11,780 --> 00:24:17,770
యొక్క స్ట్రింగ్ పొడవు తయారు చేద్దాము. ఇక్కడ మేము ఒక నిర్దిష్ట ప్రాంప్ట్ నమోదు చేయలేదు.

335
00:24:17,770 --> 00:24:19,940
కాబట్టి నాకు తెలీదు.

336
00:24:19,940 --> 00:24:23,820
నేను ఇక్కడ నా పేరు పెట్టి వెళుతున్న మరియు అందువల్ల నేను ఆ విషయాలు ఒకటి చేయవచ్చు

337
00:24:23,820 --> 00:24:29,600
నాకు అది ఇష్టం ప్రతి అక్షరం లేదా ఏదో ఒక పదం కేటాయించి పేరు. కూల్.

338
00:24:29,600 --> 00:24:31,900
కాబట్టి ఆ స్ట్రింగ్ పొడవు ఉంది.

339
00:24:33,000 --> 00:24:34,640
కాబట్టి మేము సీజర్ తిరిగి ఉన్నారు.

340
00:24:34,640 --> 00:24:38,620
మేము, మేము స్ట్రింగ్ పైగా iterate ఎలా కొన్ని పరికరాలను కలిగి

341
00:24:38,620 --> 00:24:41,250
మేము ప్రతి వ్యక్తి మూలకం యాక్సెస్ ఎలా.

342
00:24:41,250 --> 00:24:44,720
కాబట్టి ఇప్పుడు మేము ప్రోగ్రామ్ ను తిరిగి చేయవచ్చు.

343
00:24:44,720 --> 00:24:48,650
నేను ముందు, ASCII పట్టికలో, మీ ఉత్తమ స్నేహితుని, చెప్పినట్లుగా

344
00:24:48,650 --> 00:24:52,300
మీరు ప్రతి అక్షరం సంబంధం సంఖ్యలను చూడండి చూడాలని.

345
00:24:52,300 --> 00:24:55,900
ఇక్కడ మా సాదా నేను డిజ్జి ఉన్నాను అంటారు!

346
00:24:55,900 --> 00:25:01,090
ఈ అక్షరాలు ప్రతి ఒక సంఖ్య మరియు దానికి సంబంధించిన ASCII విలువను కలిగి అన్నారు

347
00:25:01,090 --> 00:25:04,710
కూడా అపాస్టిఫియర్, కూడా స్థలం కూడా ఆశ్చర్యార్థకం గుర్తును,

348
00:25:04,710 --> 00:25:06,600
కాబట్టి మీరు గుర్తుంచుకోండి చెయ్యవచ్చును.

349
00:25:06,600 --> 00:25:12,360
కాబట్టి కమాండ్ లైన్ వాదన చేర్చారు యూజర్ 6 అని మా కీ చెప్పారు.

350
00:25:12,360 --> 00:25:17,770
73 ద్వారా ప్రాతినిధ్యం ఇది నేను ఇది మొదటి అక్షరం, అంటే అర్థం ఆ

351
00:25:17,770 --> 00:25:25,610
మీరు 73 + 6 ASCII విలువను ద్వారా ప్రాతినిధ్యం ఏమైనా లేఖ వాటిని తిరిగి అనుకుంటున్నారా.

352
00:25:25,610 --> 00:25:29,020
ఈ సందర్భంలో ఆ 79 ఉంటుంది.

353
00:25:30,840 --> 00:25:35,040
ఇప్పుడు రాబోయే పాత్ర కు వెళ్లాలని మీరు అనుకుంటున్నారా.

354
00:25:35,040 --> 00:25:40,960
కాబట్టి సాదా యొక్క సూచిక 1 తదుపరి అపాస్టిఫియర్ ఉంటుంది.

355
00:25:40,960 --> 00:25:46,780
కానీ మేము కేవలం అక్షరాలు encipher మీరు గుర్తుంచుకోవాలి.

356
00:25:46,780 --> 00:25:50,040
కాబట్టి మేము, అపాస్టిఫియర్ ఒకే ఉంటాయి ఆ నిర్ధారించుకోవాలి

357
00:25:50,040 --> 00:25:54,310
మేము 39 నుండి ఏ 45 మార్చలేని ఉంది.

358
00:25:54,310 --> 00:25:57,150
మేము అపాస్ట్రఫీని గా ఉంచాలని.

359
00:25:57,150 --> 00:26:00,780
కాబట్టి మేము కేవలం అక్షరాలు encipher కు గుర్తుంచుకోవాలనుకుంటున్న

360
00:26:00,780 --> 00:26:04,560
మేము ఇతర చిహ్నాలు అన్ని మా కార్యక్రమంలో మారదు మీరు ఎందుకంటే.

361
00:26:04,560 --> 00:26:07,130
మేము కావలసిన మరొక విషయం క్యాపిటలైజేషన్ ఉంచాలనే.

362
00:26:07,130 --> 00:26:10,250
కాబట్టి మీరు ఒక పెద్ద అక్షరం ఉన్నప్పుడు, అది ఒక పెద్ద వంటి ఉండడానికి ఉండాలి.

363
00:26:10,250 --> 00:26:12,830
Lowercases చిన్న వంటి ఉండడానికి ఉండాలి.

364
00:26:13,620 --> 00:26:19,480
కాబట్టి కొన్ని ఉపయోగకరమైన విధులు మాత్రమే enciphering అక్షరాలు వ్యవహరించే చెయ్యడానికి

365
00:26:19,480 --> 00:26:22,380
మరియు విషయాలు క్యాపిటలైజేషన్ సంరక్షించడానికి ఉంచడానికి

366
00:26:22,380 --> 00:26:25,130
isalpha, isupper, islower విధులు ఉంది.

367
00:26:25,130 --> 00:26:29,270
కాబట్టి ఈ మీరు బూలియన్ విలువ తిరిగి క్రియలు.

368
00:26:29,270 --> 00:26:34,180
సాధారణంగా, ఒప్పు లేదా తప్పు. ఈ ఒక పెద్ద ఉంది? ఈ ఆల్ఫాన్యూమరిక్ ఉంది?

369
00:26:34,180 --> 00:26:37,180
ఇది తప్పనిసరిగా ఒక అక్షరం.

370
00:26:37,180 --> 00:26:41,070
ఇక్కడ మీరు ఆ ఫంక్షన్ ఉపయోగించే ఎలా 3 ఉదాహరణలు.

371
00:26:41,070 --> 00:26:47,060
సాధారణంగా, మీరు విలువ ఆ చర్య ద్వారా మీరు తిరిగి లేదో పరీక్షించుకోవచ్చు నిజమైన లేదా తప్పుగా

372
00:26:47,060 --> 00:26:49,400
ఆ ఇన్పుట్ ఆధారంగా.

373
00:26:49,400 --> 00:26:54,880
గాని encipher కాదు లేదా అది సాంకేతికలిపి లేదా పెద్ద, మొదలైనవి అని ఖచ్చితంగా ఉందని

374
00:26:54,880 --> 00:27:01,080
[విద్యార్థి] మీరు కొంచెం ఎక్కువ మరియు ఎలా మీరు వాటిని ఉపయోగించే ఆ వివరిస్తుంది? >> అవును, ఖచ్చితంగా.

375
00:27:01,080 --> 00:27:08,470
మేము తిరిగి చూడాలని అలా అయితే, ఇక్కడ మేము, ఒక రాజధాని నేను ఉందా?

376
00:27:08,470 --> 00:27:14,550
కాబట్టి మేము నేను + 6 ఓ ఎందుకంటే నేను ఓ వెళ్లే తెలుసు

377
00:27:14,550 --> 00:27:18,740
కానీ మేము O ఒక రాజధాని O. మాత్రం ఆ నిర్ధారించుకోవాలి

378
00:27:18,740 --> 00:27:22,940
కాబట్టి ప్రాథమికంగా, మా ఇన్పుట్ మార్చుకోబోతున్నారు యొక్క రకం.

379
00:27:22,940 --> 00:27:26,870
అది పెద్ద లేదా మేము అది వ్యవహరించే మార్గాన్ని మార్చడానికి రకం రెడీ లేదు కాబట్టి అని.

380
00:27:26,870 --> 00:27:32,360
కాబట్టి అప్పుడు మేము నిర్దిష్ట ఇండెక్స్ లో isupper ఫంక్షన్ ఉపయోగిస్తే,

381
00:27:32,360 --> 00:27:36,480
నిజమైన మాకు తిరిగి తద్వారా isupper ("నేను"),, కాబట్టి మేము ఇది ఉన్నత మనకు తెలుసు.

382
00:27:36,480 --> 00:27:40,360
కాబట్టి ఆ ఆధారంగా, తరువాత మేము ఒక సూత్రం వలె వెళ్తారో

383
00:27:40,360 --> 00:27:42,750
మీరు, సీజర్ లో విషయాలను మార్చేందుకు ఉపయోగించి మేము

384
00:27:42,750 --> 00:27:46,560
అది పెద్ద అయితే కనుక అప్పుడు ప్రధానంగా, కొంచెం ఫార్ములా ఉన్నట్లు జరగబోతోంది

385
00:27:46,560 --> 00:27:50,670
వంటి చిన్న వ్యతిరేకంగా. సమంజసం?

386
00:27:51,020 --> 00:27:52,760
అవును. కంగారుపడవద్దు.

387
00:27:54,900 --> 00:27:58,990
నేను చాలా సమంజసం అనిపించుకోదు ఒక లేఖ, 6 జోడించడం గురించి ఒక బిట్ మాట్లాడుకున్నారు

388
00:27:58,990 --> 00:28:05,500
మేము రకమైన అర్థం తప్ప ఈ అక్షరాలు

389
00:28:05,500 --> 00:28:08,920
పూర్ణాంకాల పరస్పర మార్పిడి యొక్క రకమైన ఉన్నాయి.

390
00:28:08,920 --> 00:28:11,250
మనం చెయ్యవలసింది మేము ఉపయోగం అవ్యక్త CASTING రకం.

391
00:28:11,250 --> 00:28:18,100
మీరు ఒక విలువను పడుతుంది పేరు ఒక బిట్ తర్వాత కాస్టింగ్ లోకి వెళ్తారో మరియు మీరు వేరే రకం మార్చడానికి

392
00:28:18,100 --> 00:28:20,440
ఇది మొదట కంటే.

393
00:28:20,440 --> 00:28:25,910
కానీ ఈ pset తో మేము పరస్పరం అక్షరాలను ఉపయోగించవచ్చు రకమైన చేయగలరు

394
00:28:25,910 --> 00:28:30,880
మరియు వాటి సంబంధిత ఇంటీజర్ విలువలకు.

395
00:28:30,880 --> 00:28:35,140
మీరు కేవలం కేవలం సింగిల్ కోట్స్ ఒక పాత్ర పొదుగు అయితే,

396
00:28:35,140 --> 00:28:40,390
అప్పుడు మీరు పూర్ణాంకం గా వ్యవహరించే, పూర్ణ తో పని చేయగలరు.

397
00:28:40,390 --> 00:28:48,040
కాబట్టి రాజధాని సి 67 సంబంధించింది. చిన్న F 102 సంబంధించినది.

398
00:28:48,040 --> 00:28:51,480
మీరు ఈ విలువలను తెలుసుకోవాలనుకుంటే మళ్లీ,, మీ ASCII పట్టిక చూడండి.

399
00:28:51,480 --> 00:28:56,160
కాబట్టి యొక్క మీరు తీసివేయడం మరియు జోడించుకోగలరు ఎలా కొన్ని ఉదాహరణలు లోకి వీడలేదు,

400
00:28:56,160 --> 00:29:03,130
మీరు నిజంగా నిజంగా ఈ అక్షరాలు పని ఎలా, పరస్పరం వాటిని ఉపయోగించండి.

401
00:29:03,870 --> 00:29:11,350
నేను ఆ ASCIIMath పూర్ణాంకం ఒక పాత్ర యొక్క అదనంగా లెక్కించేందుకు అన్నారు సే

402
00:29:11,350 --> 00:29:17,590
ఆపై ఫలితంగా పాత్ర అలాగే ఫలితంగా ASCII విలువను ప్రదర్శిస్తుంది.

403
00:29:17,590 --> 00:29:22,290
మరియు ఇక్కడ నేను చెప్పడం నేను - ఈ భాగం we'll ఒప్పందం తరువాత -

404
00:29:22,290 --> 00:29:29,100
కానీ సాధారణంగా, నేను, వినియోగదారు ఒక కీ పాటు అమలు ASCIIMath చెప్పాలి చెప్పి నేను

405
00:29:29,100 --> 00:29:30,880
మరియు నేను ఆ కీ సంఖ్య మాత్రం చెబుతూ నేను

406
00:29:30,880 --> 00:29:34,600
తో మేము ఈ పాత్ర జోడించండి చూడాలని.

407
00:29:34,600 --> 00:29:38,560
ఇక్కడ గమనించవచ్చు ఆ నేను కీ డిమాండ్ చేస్తున్నాను నుండి,

408
00:29:38,560 --> 00:29:40,590
నేను వారు నాకు 1 విషయం ఇచ్చి చేస్తున్న డిమాండ్ చేస్తున్నాను నుండి

409
00:29:40,590 --> 00:29:45,600
నేను మాత్రమే. / Asciimath మరియు ఒక కీ అంగీకరించడానికి.

410
00:29:45,600 --> 00:29:49,330
నేను argc 2 కు సమానంగా ఉంటుంది డిమాండ్ వెళుతున్న.

411
00:29:49,330 --> 00:29:54,360
అలా కాకపోతే, అప్పుడు నేను తిరిగి 1 మరియు కార్యక్రమంలో నిష్క్రమిస్తుంది వెళుతున్న.

412
00:29:55,070 --> 00:29:58,540
నేను, కీ మొదటి కమాండ్ లైన్ వాదన మాత్రం లేదు మాట్లాడుతూ నేను

413
00:29:58,540 --> 00:30:05,080
ఇది రెండవ చేస్తాడు, మరియు మీరు ఇక్కడ చూడండి వంటి

414
00:30:05,080 --> 00:30:11,790
నేను ఒక పూర్ణాంకం ఆ మలుపు వెళుతున్న.

415
00:30:15,740 --> 00:30:19,230
అప్పుడు నేను r అని ఒక పాత్ర సెట్ వెళుతున్న.

416
00:30:19,230 --> 00:30:23,970
వేరియబుల్ chr రకం నిజానికి ఒక పూర్ణ సంఖ్య అని గమనించండి.

417
00:30:23,970 --> 00:30:30,480
నేను ఒక పూర్ణాంకం వంటి r ఉపయోగించగలరు ఉన్నాను విధంగా ఈ సింగిల్ కోట్స్ తో encasing ద్వారా ఉంది.

418
00:30:33,850 --> 00:30:40,560
మేము ఒక పాత్ర కోసం ఒక ప్లేస్హోల్డర్ కలిగి ఉన్న మా printf ప్రకటన తిరిగి

419
00:30:40,560 --> 00:30:43,590
ఆపై పూర్ణాంకం ఒక ప్లేస్హోల్డర్,

420
00:30:43,590 --> 00:30:49,450
పాత్ర chr ద్వారా ప్రాతినిధ్యం, మరియు పూర్ణాంక కీ ఉంది.

421
00:30:49,450 --> 00:30:54,320
కాబట్టి అప్పుడు మేము ఫలితంగా కలిసి 2 జోడించండి చూడాలని.

422
00:30:54,320 --> 00:30:58,420
కాబట్టి మేము r జోడించండి చూడాలని + కీ ఏమైనా

423
00:30:58,420 --> 00:31:03,520
మరియు తర్వాత ఆ ఫలితంగా ముద్రించడానికి వెళుతున్న.

424
00:31:06,210 --> 00:31:14,220
కాబట్టి యొక్క asciimath తయారు చేద్దాము. ఇది తాజాగా, కనుక యొక్క కేవలం asciimath అమలు అనుమతిస్తాయి.

425
00:31:14,220 --> 00:31:18,290
మేము దీన్ని ఒక కీ ఇవ్వని కారణంగా, OH కానీ, అది ఏదీ చెయ్యవద్దు.

426
00:31:18,290 --> 00:31:23,850
కనుక ఇది కేవలం 1, మా ప్రధాన విధి తిరిగి అది మాకు తిరిగి.

427
00:31:23,850 --> 00:31:29,250
కాబట్టి అప్పుడు యొక్క కీలక లో పాస్ అయ్యేందుకు. ఒకరు ఒక సంఖ్య ఇవ్వండి. >> [విద్యార్థి] 4.

428
00:31:29,250 --> 00:31:30,920
4. సరే.

429
00:31:30,920 --> 00:31:39,280
కాబట్టి r 4 మాకు 118 యొక్క ASCII విలువను అనుగుణంగా ఉండే v, ఇవ్వాలని అన్నారు పెరిగింది.

430
00:31:39,280 --> 00:31:43,880
కాబట్టి అప్పుడు రకమైన భావన ఆ చేస్తుంది -

431
00:31:43,880 --> 00:31:51,250
అసలైన, నేను, మీరు అడగవచ్చు మీరు r + 4 118 ఉంటే r యొక్క ASCII విలువ ఏమి ఆలోచిస్తాడు?

432
00:31:53,070 --> 00:31:55,470
అప్పుడు అవును, r 114 ఉంది.

433
00:31:55,470 --> 00:32:03,010
మీరు ASCII పట్టిక చూడండి అయితే, ఖచ్చితంగా తగినంత, మీరు ఆ r 114 ద్వారా ప్రాతినిధ్యం చూస్తారు.

434
00:32:03,010 --> 00:32:08,610
కాబట్టి ఇప్పుడు మనం అక్షరాలు వరకు పూర్ణాంకాల జోడించే తెలిసిన, ఈ చాలా సాధారణమైన అంశంగా.

435
00:32:08,610 --> 00:32:12,740
మేము ముందు ఒక ఉదాహరణ చూసిన వంటి స్ట్రింగ్ పైగా iterate చూడాలని.

436
00:32:12,740 --> 00:32:17,170
అది ఒక లేఖ ఉంటే మేము తనిఖీ చేస్తాము.

437
00:32:17,170 --> 00:32:20,420
అది ఉంటే, అప్పుడు మేము కీ ఉండే వస్తువు ద్వారా బదిలీ చేస్తాము.

438
00:32:20,420 --> 00:32:23,650
ప్రెట్టీ సాధారణ, మీరు ఈ ను తప్ప,

439
00:32:23,650 --> 00:32:32,140
మీరు z, 122 ద్వారా ప్రాతినిధ్యం, అప్పుడు మీరు వేరొక పాత్ర కల్పించే చూడండి.

440
00:32:32,140 --> 00:32:37,770
మేము నిజంగా, మా వర్ణమాల లోపల ఉండండి కుడి?

441
00:32:37,770 --> 00:32:43,180
కాబట్టి మేము చుట్టూ చుట్టడం రకం విధంగా గుర్తించడానికి అవసరం.

442
00:32:43,180 --> 00:32:47,190
మీరు జెడ్ చేరుకోవడానికి మరియు మీరు ఒక నిర్దిష్ట సంఖ్యలో పెరుగుతుందని ఉంటుంది,

443
00:32:47,190 --> 00:32:51,230
మీరు ASCII అక్షరం విభాగం మించి వెళ్ళాలని అనుకుంటున్న;

444
00:32:51,230 --> 00:32:54,140
మీరు A. వరకు తిరిగి మూసివేయాలని మీరు

445
00:32:54,140 --> 00:32:58,550
అయితే మీరు ఇప్పటికీ కేసు సంరక్షించడానికి చేసిన గుర్తుంచుకోండి.

446
00:32:58,550 --> 00:33:00,980
కాబట్టి అక్షరాలు తెలుసుకోవడం చిహ్నాలు కాలేరు

447
00:33:00,980 --> 00:33:05,290
కేవలం చిహ్నాలు వంటి అలాగే మారుతున్న కావడం లేదు.

448
00:33:05,290 --> 00:33:08,170
గత pset లో మీరు ఖచ్చితంగా, అవసరం లేదు

449
00:33:08,170 --> 00:33:14,310
కానీ ఒక ఎంపికను మాడ్యులస్ ఫంక్షన్ ఉపయోగించి మీ అత్యాశ pset అమలు ఉంది.

450
00:33:14,310 --> 00:33:17,230
అయితే ఇప్పుడు మేము నిజానికి, మాడ్యులస్ ఉపయోగించాలి చూడాలని

451
00:33:17,230 --> 00:33:19,900
కాబట్టి యొక్క ఈ కొద్దిగా వెళ్ళి తెలపండి.

452
00:33:19,900 --> 00:33:26,920
ముఖ్యంగా, మీరు Y ద్వారా విభజించబడింది x మిగిలిన ఇచ్చే x మాడ్యులో y, ఉన్నప్పుడు.

453
00:33:26,920 --> 00:33:30,930
ఇక్కడ కొన్ని ఉదాహరణలు. మేము 27% 15 ఉన్నాయి.

454
00:33:30,930 --> 00:33:36,200
సాధారణంగా, మీరు ప్రతికూల లేకుండా సాధ్యం సార్లు 27 నుండి 15 వ్యవకలనం ఉన్నప్పుడు

455
00:33:36,200 --> 00:33:39,060
అప్పుడు మీరు 12 ఎడమ పొందుతాయి.

456
00:33:39,060 --> 00:33:44,650
కాబట్టి ఆ గణిత సందర్భంలో వంటి రకమైన, కానీ మేము ఎలా వాస్తవానికి ఈ ఉపయోగించవచ్చు?

457
00:33:44,650 --> 00:33:47,100
ఇది మా wrapover ఉపయోగకరంగా చేస్తాడు.

458
00:33:47,100 --> 00:33:55,420
ఈ కోసం, కేవలం నేను 3 సమూహాలుగా విభజించింది మీరు అన్ని అడిగాడు సే తెలియజేయండి.

459
00:33:55,420 --> 00:33:58,010
కొన్నిసార్లు మీరు సమూహాలు మరియు అలాంటిదే చేస్తాము.

460
00:33:58,010 --> 00:34:01,320
నేను "సరే, నేను 3 విభజించారు మీరు అన్ని కోరుకుంటున్నాను.", అన్నాడు సే

461
00:34:01,320 --> 00:34:04,240
మీరు ఎలా అలా ఉండవచ్చు?

462
00:34:04,240 --> 00:34:06,810
[వినబడని విద్యార్థి ప్రతిస్పందన] అవును, సరిగ్గా. ఆఫ్ కౌంట్. సరే.

463
00:34:06,810 --> 00:34:10,260
వాస్తవానికి అలా చేసుకుందాం. మీరు ప్రారంభించడానికి మీరు అనుకుంటున్నారా?

464
00:34:10,260 --> 00:34:13,810
1, 2, 3, 4 [విద్యార్థులు ఆఫ్ లెక్కింపు].

465
00:34:13,810 --> 00:34:16,620
కానీ గుర్తు ... >> [విద్యార్థి] ఓహ్, సారీ.

466
00:34:16,620 --> 00:34:18,730
ఒక మంచి పాయింట్.

467
00:34:18,730 --> 00:34:24,130
మీరు 4 చెప్పారు, కానీ మేము కేవలం 3 సమూహాలు కావలసిన ఎందుకంటే మేము నిజంగా మీరు 1 చెప్పాలనుకోవడం.

468
00:34:24,130 --> 00:34:30,159
కాబట్టి అప్పుడు, ఎలా - అప్పుడు ఎలా మీరు 1 అనవచ్చు ఎందుకంటే లేదు, ఒక మంచి ఉదాహరణకు?

469
00:34:30,159 --> 00:34:33,370
4 మరియు 1 మధ్య సంబంధం ఏమిటి?

470
00:34:33,370 --> 00:34:36,760
Well, 4 mod 3 1.

471
00:34:36,760 --> 00:34:41,460
మీరు కొనసాగితే కాబట్టి, మీరు 2 ఉంటుంది.

472
00:34:41,460 --> 00:34:44,540
కాబట్టి మేము 1, 2, 3, 1, 2 ఉన్నాయి.

473
00:34:44,540 --> 00:34:49,420
మరలా, మీరు నిజంగా 5 వ వ్యక్తి. ఎలా మీరు 2 బదులుగా 5 చెప్పడానికి తెలుసు?

474
00:34:49,420 --> 00:34:53,760
మీరు 5 mod 3 2 అంటారు.

475
00:34:53,760 --> 00:34:59,100
నేను ను ఎలా అనేక 3 సమూహాలను చూడాలనుకుంటే, తర్వాత క్రమంలో I. am

476
00:34:59,100 --> 00:35:02,860
కాబట్టి అప్పుడు మేము, గది మొత్తాన్ని పాటు కొనసాగింది ఉంటే

477
00:35:02,860 --> 00:35:07,760
అప్పుడు మేము ఎల్లప్పుడూ నిజానికి మేమే కు mod ఫంక్షన్ దరఖాస్తు చేస్తున్న చూడగలం

478
00:35:07,760 --> 00:35:09,990
రకమైన ఆఫ్ లెక్కించడానికి.

479
00:35:09,990 --> 00:35:14,490
మీరు మాడ్యులో ఉపయోగించడానికి ఎలా ప్రత్యక్ష ఉదాహరణ యొక్క రకంగా

480
00:35:14,490 --> 00:35:17,960
నేను ఖచ్చితంగా ఉన్నాను ఎందుకంటే మాకు చాలా బహుశా ఆ ప్రక్రియ దాటి

481
00:35:17,960 --> 00:35:19,630
మేము ఆఫ్ లెక్కించడానికి కలిగింది పేరు.

482
00:35:19,630 --> 00:35:21,840
మోడ్యులో ఏ ప్రశ్నలు?

483
00:35:21,840 --> 00:35:25,360
ఇది ఈ భావనల అర్థం చాలా ముఖ్యమైనది ఉంటుంది

484
00:35:25,360 --> 00:35:28,640
నేను మీరు అబ్బాయిలు అర్థం నిర్ధారించుకోవాలి.

485
00:35:28,640 --> 00:35:34,660
[విద్యార్థి] ఏ మిగిలిన ఉంటే, మీరు అసలు సంఖ్య ఇవ్వలేదు?

486
00:35:34,660 --> 00:35:40,430
వాటిలో మొదటి 3 యొక్క ఒక దానిని చేసిన ఉంటే, అది, వారు నిజంగా ఏం చేస్తున్నారో వారిని ను ఇచ్చింది

487
00:35:40,430 --> 00:35:43,310
లేదా వాటిని ను ఇచ్చింది [వినబడని] >> ఒక మంచి ప్రశ్న.

488
00:35:43,310 --> 00:35:48,750
మోడ్యులో ఏ మిగిలిన ఉన్నప్పుడు - మీరు 6 mod 3 కలిగి చెప్పడానికి -

489
00:35:48,750 --> 00:35:52,340
వాస్తవానికి 0 మీరు తిరిగి ఇస్తుంది.

490
00:35:53,670 --> 00:35:57,290
మేము ఒక బిట్ తర్వాత గురించి మాట్లాడదాము.

491
00:35:58,810 --> 00:36:07,720
అవును, ఉదాహరణకు, 3 వ వ్యక్తి - 3 mod 3 వాస్తవానికి 0 అయితే ఆమె 3 చెప్పారు.

492
00:36:07,720 --> 00:36:14,900
కాబట్టి ఆ ఉదాహరణకు, ఒక అంతర్గత క్యాచ్ వంటి రకమైన యొక్క,

493
00:36:14,900 --> 00:36:17,620
mod అప్పుడు 0 అయితే ఓకే ఇష్టం, 3 వ వ్యక్తి వెళుతున్న.

494
00:36:17,620 --> 00:36:22,740
కానీ మేము 0 తరువాత ఏమి వ్యవహరించే మీరు ఎలా రకమైన లోకి వస్తాయి.

495
00:36:22,740 --> 00:36:32,750
కాబట్టి ఇప్పుడు మేము ఏదో కుడి లేఖ జెడ్ మ్యాపింగ్ ఒక మార్గం ఉంది.

496
00:36:32,750 --> 00:36:34,920
కాబట్టి ఇప్పుడు మేము ఈ ఉదాహరణలు ద్వారా మారారు

497
00:36:34,920 --> 00:36:37,880
మేము రకమైన సీజర్ పని ఎలా చూడండి.

498
00:36:37,880 --> 00:36:42,640
మీరు 2 వర్ణమాలలు చూడండి మరియు మీరు వాటిని తరలించడం చూడండి.

499
00:36:42,640 --> 00:36:44,430
కాబట్టి యొక్క ప్రయత్నించండి మరియు ఫార్ములా పరంగా ఆ వ్యక్తం తెలియజేయండి.

500
00:36:44,430 --> 00:36:46,940
ఈ ఫార్ములా వాస్తవానికి, స్పెక్ లో మీరు ఇవ్వబడుతుంది

501
00:36:46,940 --> 00:36:52,070
కానీ ప్రతి వేరియబుల్ అర్థం ద్వారా లుక్ యొక్క లెట్స్ రకమైన.

502
00:36:52,070 --> 00:36:55,000
మా తుది ఫలితంగా సాంకేతికపాఠం అని అన్నారు.

503
00:36:55,000 --> 00:36:58,300
కాబట్టి ఈ అని సాంకేతికపాఠం యొక్క ith పాత్ర

504
00:36:58,300 --> 00:37:02,500
సాదా యొక్క ith పాత్ర అనుగుణంగా అన్నారు.

505
00:37:02,500 --> 00:37:08,130
మేము ఎల్లప్పుడూ పైకి ఈ విషయాలు లైనింగ్ అనుకుంటే ఎందుకంటే భావన కల్పిస్తుంది.

506
00:37:08,130 --> 00:37:13,480
కాబట్టి అది మా కీ ఇది సాంకేతికపాఠం ప్లస్ k యొక్క ith పాత్ర చేస్తాడు -

507
00:37:13,480 --> 00:37:17,230
భావన కల్పిస్తుంది - మరియు తర్వాత మేము ఈ mod 26 ఉన్నాయి.

508
00:37:17,230 --> 00:37:19,860
మేము జెడ్ ఉన్నప్పుడు తిరిగి గుర్తుంచుకో

509
00:37:19,860 --> 00:37:24,190
మేము పాత్ర పొందడానికి లేదు, కాబట్టి మేము అది MoD అనుకున్నారు

510
00:37:24,190 --> 00:37:26,540
వర్ణమాల సర్దుబాటు మరియు రకం.

511
00:37:26,540 --> 00:37:33,430
జెడ్ తర్వాత మీరు ఒక వెళ్లాల్సి ఉంది, బి, మీరు కుడి సంఖ్య c, d, కాకముందు వరకు.

512
00:37:33,430 --> 00:37:44,690
కాబట్టి మేము తెలిసిన జెడ్, జెడ్ a, b, c, d, E, F వచ్చిన తర్వాత ఎందుకంటే + 6, మాకు F చూపినట్లయితే.

513
00:37:44,690 --> 00:37:52,530
కాబట్టి యొక్క మేము జెడ్ + 6 మాకు F ఇవ్వాలని అన్నారు ఖచ్చితంగా తెలుసు గుర్తు తెలియజేయండి.

514
00:37:52,530 --> 00:38:03,530
ASCII విలువలు లో, z 122 మరియు 102 F ఉంది.

515
00:38:03,530 --> 00:38:10,570
కాబట్టి మేము మా సీజర్ ఫార్ములా తయారు చేసే కొన్ని వెళ్లేందుకు కలిగి మాకు 102 ఇవ్వటానికి

516
00:38:10,570 --> 00:38:13,590
122 లో తీసుకున్న తరువాత.

517
00:38:13,590 --> 00:38:19,550
మేము ఈ ఫార్ములా, వాస్తవానికి మీరు 24 ఇచ్చే ('z' + 6)% 26, దరఖాస్తు అయితే

518
00:38:19,550 --> 00:38:25,980
122 + 6 128 ఎందుకంటే; 128% 26 మీరు 24 మిగిలిన ఇస్తుంది.

519
00:38:25,980 --> 00:38:29,140
కానీ నిజంగా F కాదు. ఆ ఖచ్చితంగా 102 కాదు.

520
00:38:29,140 --> 00:38:33,590
కూడా వర్ణమాలలో 6 లేఖ కాదు.

521
00:38:33,590 --> 00:38:41,550
కాబట్టి సహజంగా, మేము ట్వీకింగ్ ఈ కొద్దిగా విధంగా ఉండాలి.

522
00:38:42,970 --> 00:38:51,340
సాధారణ వర్ణమాల ప్రకారం, మేము z 26TH అక్షరం మరియు F 6 అని తెలుసు.

523
00:38:51,340 --> 00:38:55,460
కానీ మేము కంప్యూటర్ సైన్స్ లో ఉన్నాము, కాబట్టి మాకు 0 వద్ద ఇండెక్స్ చూడాలని.

524
00:38:55,460 --> 00:39:00,690
బదులుగా z సంఖ్య 26 గా కాబట్టి అప్పుడు, మేము అది యొక్క సంఖ్య 25 చెప్పడానికి వెళుతున్న

525
00:39:00,690 --> 00:39:02,630
ఒక 0 ఎందుకంటే.

526
00:39:02,630 --> 00:39:04,770
కాబట్టి ఇప్పుడు యొక్క ఈ ఫార్ములా దరఖాస్తు తెలియజేయండి.

527
00:39:04,770 --> 00:39:11,710
మేము z మీరు 31 ఇస్తుంది, 25 + 6 ప్రాతినిధ్యం ఉంటాయి.

528
00:39:11,710 --> 00:39:15,790
మరియు 31 mod 26 ఒక మిగిలిన వంటి మీరు 5 ఇస్తుంది.

529
00:39:15,790 --> 00:39:20,500
మేము F వర్ణమాల 5 వ అక్షరం తెలుసు ఎందుకంటే, ఆ పరిపూర్ణ ఉంది.

530
00:39:20,500 --> 00:39:26,400
కానీ ఇప్పటికీ సరైన, F కాదు? ఇప్పటికీ 102 కాదు.

531
00:39:26,400 --> 00:39:32,730
కాబట్టి ఈ pset కోసం, ఒక సవాలు సంబంధం కనుగొనేందుకు ప్రయత్నిస్తున్న ఉంటుంది

532
00:39:32,730 --> 00:39:36,910
ఈ ASCII విలువలు మరియు అక్షర సూచిక మధ్య మార్పిడి మధ్య.

533
00:39:36,910 --> 00:39:40,280
ముఖ్యంగా, మీరు చెయ్యవచ్చును ఏమిటి, మీరు, ASCII విలువలు తో ప్రారంభం కావాలి

534
00:39:40,280 --> 00:39:45,390
కానీ అప్పుడు మీరు ఏదో ఒక అక్షర సూచిక ఆ అనువదించాలనుకుంటున్న

535
00:39:45,390 --> 00:39:52,610
అప్పుడు అది ఏ అక్షరం లెక్కించేందుకు - సాధారణంగా, దాని అక్షర సూచిక ఏమిటి

536
00:39:52,610 --> 00:39:57,660
సాంకేతికలిపి పాత్ర - ఆ తిరిగి ASCII విలువలు అనువదించు.

537
00:39:57,660 --> 00:40:04,870
మీరు మీ ASCII పట్టిక అవుట్ రెచ్చిపోయినప్పుడు చేస్తే, అప్పుడు 102 మరియు 5, ప్రయత్నించండి మరియు మధ్య సంబంధాలు కనుగొనడానికి, సే

538
00:40:04,870 --> 00:40:10,440
లేదా 122 మరియు 25.

539
00:40:12,140 --> 00:40:15,690
మేము ఆదేశ పంక్తి వాదనలు నుండి మా కీ సంపాదించిన తర్వాత, మేము, సాదా సంపాదించిన చేసిన

540
00:40:15,690 --> 00:40:17,520
మేము అది enciphered చేసిన.

541
00:40:17,520 --> 00:40:19,820
ఇప్పుడు మేము వదలి అన్ని ప్రింట్ ఉంది.

542
00:40:19,820 --> 00:40:22,040
మేము ఈ వివిధ రెండు మార్గాలు పని చేయడు.

543
00:40:22,040 --> 00:40:24,570
మేము సహకరించు వంటి మనం చేయగల వాస్తవానికి ప్రింట్ చేయబడుతుంది.

544
00:40:24,570 --> 00:40:28,250
మేము స్ట్రింగ్ లో అక్షరాల కంటే iterate వంటి,

545
00:40:28,250 --> 00:40:31,660
మేము అది లెక్కించేందుకు మేము కేవలం సరైన చేసి, ప్రింట్ చేయవచ్చు.

546
00:40:31,660 --> 00:40:36,030
ప్రత్యామ్నాయంగా, మీరు కూడా వ్యూహంలో ఇది నిల్వ మరియు అక్షరాలు ఒక వరుస కలిగి

547
00:40:36,030 --> 00:40:39,280
మరియు చివరిలో ఆ వ్యూహరచనలు పైగా iterate మరియు దీనిని ప్రింట్.

548
00:40:39,280 --> 00:40:40,980
కాబట్టి మీరు ఆ ఎంపికలను ఒక జంట కలిగి ఉంటాయి.

549
00:40:40,980 --> 00:40:47,280
మరియు% సి ఒక పాత్ర ప్రింటింగ్ కోసం ప్లేస్హోల్డర్ మాత్రం గుర్తుంచుకోండి.

550
00:40:47,280 --> 00:40:50,420
, అందువల్ల మేము సీజర్ కలిగి, మరియు ఇప్పుడు మేము విజెనెరే కొనసాగండి

551
00:40:50,420 --> 00:40:57,580
ఇది సీజర్ సమానమైన కానీ కొద్దిగా సంక్లిష్టంగా ఉంటుంది.

552
00:40:57,580 --> 00:41:03,310
కాబట్టి ముఖ్యంగా విజెనెరే మీకు ఒక కీవర్డ్ అక్కడ కూడా చూడాలని ఉంది.

553
00:41:03,310 --> 00:41:06,510
బదులుగా ఒక సంఖ్య యొక్క కాబట్టి, మీరు, ఒక స్ట్రింగ్ చూడాలని

554
00:41:06,510 --> 00:41:09,200
అందువలన, మీ కీవర్డ్ వ్యవహరించే జరగబోతోంది.

555
00:41:09,200 --> 00:41:14,440
అప్పుడు, మామూలుగానే, మీరు యూజర్ నుండి ఒక స్ట్రింగ్ కొరకు ప్రేరణ పొందండి చూడాలని

556
00:41:14,440 --> 00:41:19,050
మరియు తర్వాత ఇది encipher మరియు తరువాత వారిని సాంకేతికపాఠం తిరిగి ఇవ్వండి.

557
00:41:19,050 --> 00:41:24,650
నేను అన్నాడు కనుక, అది, ఒక నిర్దిష్ట సంఖ్యలో తరలించడం యొక్క తప్ప, సీజర్ సమానమైన యొక్క

558
00:41:24,650 --> 00:41:30,620
సంఖ్య వాస్తవానికి పాత్ర నుండి పాత్ర ప్రతి సమయాన్ని మార్చడానికి అన్నారు.

559
00:41:30,620 --> 00:41:34,890
మార్చేందుకు నిజమైన సంఖ్య సూచించుటకు, అది కీబోర్డ్ అక్షరాల ప్రాతినిధ్యం ఉంది.

560
00:41:34,890 --> 00:41:43,150
ఉదాహరణకు మీరు ఒక ఒక మార్పు నమోదు చేసుకుంటూ ఉంటే, అప్పుడు ఆ 0 ఒక షిఫ్ట్ అనుగుణంగా ఉంటుంది.

561
00:41:43,150 --> 00:41:45,900
కాబట్టి మళ్ళీ అక్షర సూచిక తిరిగి ఉంది.

562
00:41:45,900 --> 00:41:49,100
మీరు మేము నిజంగా ASCII విలువలు వ్యవహరించే చేస్తున్న చూస్తూ ఉన్నట్లయితే ఉపయోగకరంగా ఉండవచ్చు ఏమి

563
00:41:49,100 --> 00:41:51,790
అలాగే అక్షరాలు అలాగే అక్షర సూచిక వంటి

564
00:41:51,790 --> 00:41:58,020
బహుశా, 25 ద్వారా 0 యొక్క అక్షర సూచిక చూపే మీ స్వంత ASCII పట్టిక కనుగొనడానికి లేదా తయారు

565
00:41:58,020 --> 00:42:03,750
తద్వారా మీరు రకమైన సంబంధం z ద్వారా, మరియు ASCII విలువలు చూడగలరు

566
00:42:03,750 --> 00:42:07,020
మరియు గీసేందుకు మరియు కొన్ని నమూనాలు ప్రయత్నించండి మరియు కనుగొనండి.

567
00:42:07,020 --> 00:42:11,010
అదేవిధంగా, మీరు F ద్వారా కొన్ని ఉదాహరణకు వద్ద తరలించడం జరిగింది ఉంటే -

568
00:42:11,010 --> 00:42:21,110
మరియు ఈ గాని చిన్న లేదా పెద్ద F ఉంది - ఆ 5 అనుగుణంగా ఉంటుంది.

569
00:42:21,110 --> 00:42:24,180
మేము ఇప్పటివరకు మంచి భావిస్తున్నారా?

570
00:42:25,770 --> 00:42:30,050
విజెనెరే సూత్రం ఒక భిన్నమైనది.

571
00:42:30,050 --> 00:42:32,960
సాధారణంగా, మీరు అది సీజర్ వంటిది ఆ చూడండి

572
00:42:32,960 --> 00:42:37,390
తప్ప బదులుగా కేవలం k మేము k సూచిక j ఉన్నాయి.

573
00:42:37,390 --> 00:42:44,810
మేము, ఎందుకంటే తప్పనిసరిగా కీవర్డ్ యొక్క పొడవు నేను ఉపయోగించి చేస్తున్నట్లు గమనించండి

574
00:42:44,810 --> 00:42:49,850
మా సాంకేతికపాఠం యొక్క పొడవు అవసరం లేదు.

575
00:42:49,850 --> 00:42:56,130
మేము నేను తర్వాత ఒక బిట్ కలిగి ఒక ఉదాహరణ చూడండి ఈ ఒక బిట్ స్పష్టమైన ఉంటుంది.

576
00:42:56,130 --> 00:43:03,160
సాధారణంగా, మీరు ohai ఒక ముఖ్య పదాన్ని మీ ప్రోగ్రామ్ అమలు చేస్తే,

577
00:43:03,160 --> 00:43:08,560
ఆ ప్రతిసారీ, ohai మీ మార్పు మాత్రం దీని అర్థం.

578
00:43:08,560 --> 00:43:11,060
కాబట్టి మీరు మీ కీవర్డ్ లో ఏమిటో స్థానం బట్టి,

579
00:43:11,060 --> 00:43:15,800
మీరు ఆ మొత్తం మీ కొన్ని సాంకేతికపాఠం పాత్ర మార్చేందుకు వెళుతున్న.

580
00:43:15,800 --> 00:43:19,630
మళ్లీ, కేవలం సీజర్ వంటి మేము విషయాలను క్యాపిటలైజేషన్ సంరక్షించబడింది నిర్ధారించుకోవాలి

581
00:43:19,630 --> 00:43:22,900
మరియు మేము మాత్రమే encipher అక్షరాలు, కాని అక్షరాలు లేదా ఖాళీలను.

582
00:43:22,900 --> 00:43:26,330
కాబట్టి, మీరు ఉపయోగించి ఉండవచ్చు క్రియలు న సీజర్ తిరిగి చూడండి

583
00:43:26,330 --> 00:43:32,570
మీరు విషయాలను మార్చడానికి మరియు ఇక్కడ మీ ప్రోగ్రామ్ ఆ దరఖాస్తు ఎలా నిర్ణయించుకుంది విధంగా.

584
00:43:32,570 --> 00:43:35,260
కాబట్టి ఇది మ్యాప్ చూద్దాం.

585
00:43:35,260 --> 00:43:39,680
మేము GetString వినియోగదారు నుండి సంపాదించిన చేసిన సాదా కలిగి

586
00:43:39,680 --> 00:43:44,090
ఈ చెప్పడం ... CS50 ఉంది!

587
00:43:44,090 --> 00:43:47,090
అప్పుడు మేము ohai ఒక ముఖ్య పదాన్ని కలిగి ఉన్నాయి.

588
00:43:47,090 --> 00:43:50,930
మొదటి 4 అక్షరాలు అందంగా సులువు.

589
00:43:50,930 --> 00:43:55,580
మేము T, o ద్వారా మార్చబడుతుంది అన్నారు తెలుసు

590
00:43:55,580 --> 00:44:01,990
h h ద్వారా మార్చబడుతుంది అన్నారు అప్పుడు, నేను ద్వారా మార్చబడుతుంది అన్నారు.

591
00:44:01,990 --> 00:44:04,610
ఇక్కడ మీరు ఒక 0 ప్రాతినిధ్యం చూడండి

592
00:44:04,610 --> 00:44:11,940
కాబట్టి అప్పుడు ముగింపు విలువ వాస్తవానికి ముందు కేవలం ఒకే అక్షరం.

593
00:44:11,940 --> 00:44:15,250
అప్పుడు s నేను ద్వారా బదిలీ అవుతుంది.

594
00:44:15,250 --> 00:44:19,370
కానీ మీరు ఇక్కడ ఈ బిందువులను.

595
00:44:19,370 --> 00:44:25,960
మేము అప్పుడు మేము ఏదైనా దాన్ని మార్చడానికి లేదు, ఆ encipher చేయకూడదని

596
00:44:25,960 --> 00:44:31,280
మరియు కేవలం మారకుండా కాలం ముద్రించాలా.

597
00:44:31,280 --> 00:44:38,020
[విద్యార్థి] నేను మీరు ఈ ద్వారా బదిలీ అవుతుంది తెలుసు ఎలా అర్థం లేదు - ఎక్కడ చేశాడు - >> ఓహ్, సారీ.

598
00:44:38,020 --> 00:44:41,620
ఇక్కడ ఎగువన మీరు ఇక్కడ ఆ ఆదేశ పంక్తి వాదన ohai, చూడండి

599
00:44:41,620 --> 00:44:43,740
ఆ కీవర్డ్ చేస్తాడు.

600
00:44:43,740 --> 00:44:49,550
కాబట్టి ప్రాథమికంగా, మీరు కీవర్డ్ లో అక్షరాల కంటే సైకిల్ చేస్తున్నారు.

601
00:44:49,550 --> 00:44:52,020
[విద్యార్థి] కాబట్టి o అదే బదిలీ కావడం ఉంది -

602
00:44:52,020 --> 00:44:56,260
కాబట్టి o వర్ణమాలలో ఒక నిర్దిష్ట సంఖ్యలో సూచించదు.

603
00:44:56,260 --> 00:44:58,400
[విద్యార్థి] రైట్. కానీ మీరు CS50 భాగంగా ఎక్కడ నుండి వచ్చింది?

604
00:44:58,400 --> 00:45:02,540
ఓహ్. మీరు వంటి ఎక్కడ GetString యొక్క "నాకు ఎన్కోడ్ ఒక స్ట్రింగ్ ఇవ్వండి."

605
00:45:02,540 --> 00:45:07,510
[విద్యార్థి] వారు మీరు మారిపోయే ఆ వాదన ఇవ్వాలని వెళుతున్న

606
00:45:07,510 --> 00:45:09,380
మరియు మీరు మీ మొదటి స్ట్రింగ్ కోసం అడుగుతాము. >> అవును.

607
00:45:09,380 --> 00:45:12,440
కాబట్టి వారు అమలు చేసేటప్పుడు, వారు కీవర్డ్ ఉన్నాయి చూడాలని

608
00:45:12,440 --> 00:45:14,740
కమాండ్ లైన్ వాదనలు వారు అమలు చేసినప్పుడు.

609
00:45:14,740 --> 00:45:19,740
,, తక్కువ కాదు అప్పుడు మీరు వారు నిజానికి మీరు 1 ఇచ్చిన చేసిన తనిఖీ చేసిన మరియు మరింత

610
00:45:19,740 --> 00:45:23,750
అప్పుడు మీరు ఒక స్ట్రింగ్ కోసం ప్రాంప్ట్ చూడాలని, చెప్పడానికి, "నాకు ఒక స్ట్రింగ్ ఇవ్వండి."

611
00:45:23,750 --> 00:45:27,630
ఈ సందర్భంలో వారు మీరు ఈ ఇచ్చాను పేరు కాబట్టి ఆ ... CS50 ఉంది!

612
00:45:27,630 --> 00:45:32,090
కాబట్టి మీరు ఆ ఉపయోగించడానికి మరియు ohai ఉపయోగించడానికి మరియు పైగా iterate చూడాలని.

613
00:45:32,090 --> 00:45:38,200
ఇక్కడ మేము కాలాలు ఎన్క్రిప్ట్ పైగా హాజరు గమనించండి,

614
00:45:38,200 --> 00:45:51,660
కానీ ohai, తదుపరి కోసం మా స్థానం నుండి మేము o ఉపయోగిస్తారు.

615
00:45:51,660 --> 00:45:54,990
ఈ సందర్భంలో ఇది 4 అని ఎందుకంటే చూడటానికి కాస్త కష్టం

616
00:45:54,990 --> 00:45:57,710
కాబట్టి యొక్క ఒక బిట్ చెయ్యనివ్వండి. కేవలం నా కొనసాగించు.

617
00:45:57,710 --> 00:46:02,960
అప్పుడు మేము వరుసగా o మరియు h అనువదించారు ఇవి నేను మరియు s, ఉన్నాయి.

618
00:46:02,960 --> 00:46:09,370
అప్పుడు మేము ఒక స్పేస్, కాబట్టి, అప్పుడు మేము ఖాళీలను encipher కు వెళ్ళడం లేదు తెలుసు.

619
00:46:09,370 --> 00:46:18,930
కానీ నోటీసు ఆ బదులుగా ఇక్కడ ఈ స్పాట్ లో వెళుతున్న,

620
00:46:18,930 --> 00:46:28,330
మేము ఒక ద్వారా ఎన్క్రిప్ట్ చేసిన - ఇక్కడే - మీరు ఆ చూడవచ్చు నాకు తెలీదు.

621
00:46:28,330 --> 00:46:33,710
అది మీరు నిజంగా ముందుగా నిర్ణయించిన ఇష్టం సే, o ఇక్కడ వస్తుంది కాదు, h ఇక్కడ వస్తుంది,

622
00:46:33,710 --> 00:46:39,200
ఒక ఇక్కడకు వెళ్తుంది, నేను ఓ, h, ఒక, i, o, h, ఒక, i., ఇక్కడ వస్తుంది మీరు ఆ పని చేయడం లేదు.

623
00:46:39,200 --> 00:46:43,760
మీరు ముఖ్యపదాన్ని మీ స్థానం బదిలీ

624
00:46:43,760 --> 00:46:51,020
మీరు నిజంగా ఒక నిజమైన లేఖ ఎన్క్రిప్ట్ కావడం చేస్తున్న తెలిసిన ఉన్నప్పుడు.

625
00:46:51,020 --> 00:46:53,920
ఆ రకమైన సమంజసం లేదు?

626
00:46:53,920 --> 00:46:55,800
సరే.

627
00:46:56,490 --> 00:46:58,500
కాబట్టి కొన్ని రిమైండర్లు.

628
00:46:58,500 --> 00:47:03,760
మీరు మాత్రమే మీ కీవర్డ్ తరువాతి అక్షరం చేరుకునేందుకు ఆ నిర్ధారించుకోవాలి

629
00:47:03,760 --> 00:47:06,390
మీ పాఠంలోని అక్షరం ఒక అక్షరం ఉంది.

630
00:47:06,390 --> 00:47:09,120
మేము o వద్ద ఉన్నారు చెప్పడానికి.

631
00:47:09,120 --> 00:47:19,310
మేము తదుపరి పాత్ర సాదా యొక్క నేను సూచిక, ఉదాహరణకు, ఒక సంఖ్య అని గమనించండి.

632
00:47:19,310 --> 00:47:31,630
మేము మరొక అక్షరం చేరుకునే వరకు అప్పుడు, j, మా కీవర్డ్ కోసం సూచిక ముందుకు లేదు.

633
00:47:31,630 --> 00:47:36,230
మరలా, మీరు కూడా కీవర్డ్ ప్రారంభంలో మిమ్మల్ని చుట్టబెట్టిన ఆ నిర్ధారించుకోవాలి

634
00:47:36,230 --> 00:47:37,770
మీరు చివరిలో ఉన్నప్పుడు.

635
00:47:37,770 --> 00:47:42,030
మీరు ఇక్కడ మేము నేను ఉన్నాము చూసినట్లయితే, తర్వాత ఒక o ఉండాలి.

636
00:47:42,030 --> 00:47:47,690
కాబట్టి మీరు మీ కీవర్డ్ ప్రారంభానికి చుట్టబెట్టిన చేసే విధంగా కావలసిన

637
00:47:47,690 --> 00:47:49,470
మీరు ముగింపు చేరుకోవడానికి ప్రతి సమయం.

638
00:47:49,470 --> 00:47:55,040
మరియు మరలా, ఏ ఆపరేటర్లు రకమైన చుట్టూ అంటించే ఆ సందర్భంలో ఉపయోగపడుతుంది?

639
00:47:56,630 --> 00:47:59,840
ఉదాహరణకు ఆఫ్ లెక్కింపు లో ఇష్టపడుతున్నారు.

640
00:47:59,840 --> 00:48:03,710
[విద్యార్థి] శాతం సంకేతం. >> అవును, మాడ్యులో ఇది శాతం సైన్.

641
00:48:03,710 --> 00:48:11,250
కాబట్టి మాడ్యులో మీ ohai లో ఇండెక్స్ మీద మూసివేయాలని ఉంటుంది ఇక్కడ ఉపయోగకరంగా ఉండగలదో.

642
00:48:11,250 --> 00:48:17,700
మరియు కేవలం ఒక శీఘ్ర సూచన: ఒక బిట్ లెక్కింపు ఆఫ్ వంటి కీవర్డ్ పైగా చుట్టే ఆలోచించడానికి ప్రయత్నించండి

643
00:48:17,700 --> 00:48:23,590
3 సమూహాలు, 4 వ వ్యక్తి, ఇక్కడ ఉంటే

644
00:48:23,590 --> 00:48:30,610
వారు మాట్లాడుతూ వారి సంఖ్య 1 ఇది 4 mod 3, ఉంది.

645
00:48:30,610 --> 00:48:32,880
కాబట్టి ఆ విధంగా ప్రయత్నించండి మరియు ఆలోచించండి.

646
00:48:34,770 --> 00:48:42,740
మీరు అప్పుడు KJ ci మరియు తరువాత pi కానీ అక్కడ, ఫార్ములా చూసిన, వంటి

647
00:48:42,740 --> 00:48:44,700
ఆ ట్రాక్ ఆ నిర్ధారించుకోవాలి.

648
00:48:44,700 --> 00:48:47,580
మీరు నేను కాల్ లేదు, మీరు, ఇది j కాల్ లేదు

649
00:48:47,580 --> 00:48:53,270
కానీ మీరు మీ పాఠంలోని వద్ద మీరు ఈ స్థానంలో ట్రాక్ ఆ నిర్ధారించుకోవాలి

650
00:48:53,270 --> 00:48:55,790
అలాగే స్థానం వంటి మీరు మీ కీవర్డ్ లో వద్ద ఉన్నట్లు

651
00:48:55,790 --> 00:48:59,840
ఆ అవసరం అదే మాత్రం కాదు ఎందుకంటే.

652
00:48:59,840 --> 00:49:06,400
కీవర్డ్ లేదు మాత్రమే - మీ సాదా కంటే పూర్తిగా భిన్నంగా పొడవు ఉంటుంది.

653
00:49:06,400 --> 00:49:09,140
అలాగే, మీ సాదా, సంఖ్యలు మరియు అక్షరాలు ఉన్నాయి

654
00:49:09,140 --> 00:49:14,450
కాబట్టి ఇది ఖచ్చితంగా కలిసి మ్యాచ్ మాత్రం కాదు. అవును.

655
00:49:14,450 --> 00:49:19,280
[విద్యార్థి] అక్కడ కేసు మార్చేందుకు క్రియ?

656
00:49:19,280 --> 00:49:24,530
మీరు రాజధాని కి ఒక మార్చవచ్చు? >> అవును, ఖచ్చితంగా ఉంది.

657
00:49:24,530 --> 00:49:27,890
మీరు తనిఖీ చేయవచ్చు - నేను toupper, అన్ని 1 పదం భావిస్తున్నారు.

658
00:49:30,650 --> 00:49:36,310
కానీ మీరు విషయాలు సాంకేతికలిపి మరియు టెక్స్ట్ నిల్వ చేయడానికి ప్రయత్నిస్తున్న సమయంలో,

659
00:49:36,310 --> 00:49:39,350
అది ప్రత్యేక సందర్భాలలో కలిగి ఉత్తమ ప్రధానంగా ఉంది.

660
00:49:39,350 --> 00:49:42,040
అది ఒక పెద్ద అయితే, మీరు ఈ ద్వారా మారిపోయే కావలసిన

661
00:49:42,040 --> 00:49:46,460
మీ సూత్రంలో, మీరు తిరిగి చూడాలని మేము గో యొక్క రకాన్ని కలిగి ఎలా ఎందుకంటే

662
00:49:46,460 --> 00:49:50,900
పరస్పరం సంఖ్యలు ప్రాతినిధ్యం యొక్క ASCII మార్గం మధ్య

663
00:49:50,900 --> 00:49:55,020
అసలు అక్షర సూచిక, మేము నిర్ధారించుకోవాలి

664
00:49:55,020 --> 00:50:01,850
మీరు వెళుతున్న ఆ నమూనా యొక్క కొన్ని రకమైన ఉన్నట్లు జరగబోతోంది.

665
00:50:01,850 --> 00:50:04,580
వాస్తవానికి నమూనా మరొక గమనిక.

666
00:50:04,580 --> 00:50:07,250
మీరు ఖచ్చితంగా సంఖ్యలు వ్యవహరించే కావడం చేస్తున్నారు.

667
00:50:07,250 --> 00:50:11,280
శైలి యొక్క ఒక ఉదాహరణ, ఇది మ్యాజిక్ సంఖ్యలు ఉపయోగించడానికి లేదు ప్రయత్నించండి.

668
00:50:11,280 --> 00:50:18,470
మీరు ద్వారా ప్రతి సమయ మార్పిడి ఏదో మీరు చెప్పడానికి -

669
00:50:18,470 --> 00:50:22,400
మీరు ఏదో బదిలీ కావడం చేసినప్పుడు సరే, సూచన కాబట్టి, మరొక స్పాయిలర్ ఉంది

670
00:50:22,400 --> 00:50:26,310
కొంత ద్వారా, ఒక వాస్తవ సంఖ్య ద్వారా ప్రాతినిథ్యం లేదు ప్రయత్నించండి

671
00:50:26,310 --> 00:50:32,810
కానీ ప్రయత్నించండి మరియు మీరు రకమైన మరింత అర్ధవంతం ఇది ASCII విలువను ఉపయోగించవచ్చు చూడండి.

672
00:50:32,810 --> 00:50:35,470
మరో గమనిక: మేము సూత్రాలు రంజింప చేయడానికి ప్రయత్నిస్తున్నాము,

673
00:50:35,470 --> 00:50:41,200
మీ TF రకమైన మీరు ఉపయోగిస్తూ ఉండవచ్చు ఏమి నమూనా తెలుస్తుంది అయినప్పటికీ,

674
00:50:41,200 --> 00:50:44,430
మీ వ్యాఖ్యలు రకమైన లో ఉత్తమ తర్కం, ఇష్టం, వివరించేందుకు

675
00:50:44,430 --> 00:50:51,880
"నేను ఈ నమూనా ఉపయోగించి నేను ..." మరియు రకమైన మీ వ్యాఖ్యలలో క్లుప్తమైన నమూనా వివరిస్తాయి.

676
00:50:54,090 --> 00:50:58,990
[ఈ walkthrough 2] ఇతర ప్రశ్నలు లేకపోతే, అప్పుడు నేను కొద్దిగా కోసం ఇక్కడ ఉండడానికి చేస్తాము.

677
00:50:58,990 --> 00:51:04,370
క్రిప్టో మరియు ధన్యవాదాలు: మీ pset 2 అదృష్టం.

678
00:51:06,070 --> 00:51:08,620
[విద్యార్థి] ధన్యవాదాలు. >> ధన్యవాదాలు.

679
00:51:09,220 --> 00:51:10,800
[మీడియా ఆఫ్లైన్ పరిచయ]