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
सही सभी. सबको नमस्ते, और 2 Walkthrough के लिए आपका स्वागत है.

5
00:00:10,750 --> 00:00:14,330
सबसे पहले, मैं आप 1 pset परिष्करण के लिए बधाई देना चाहता हूँ.

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
आप 1 pset को देखो और आप कहते हैं, "अरे, मैं कर सकता है कि 5 मिनट में."

10
00:00:29,820 --> 00:00:35,700
तो पता है और विश्वास है कि इस के अंत में आप निश्चित रूप से 1 pset काफी सरल लगता हूँ.

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
walkthroughs के दौरान समस्या सेट करने के हर एक तरह के माध्यम से जाने के लिए

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
[2 pset: क्रिप्टोप्लग - Zamyla चान - zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[Pset2 - 0. सवालों की एक धारा - 1. सीज़र - 2. Vigenere]

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
फिर समस्या सेट के दूसरे भाग Vigenere है,

33
00:01:59,090 --> 00:02:01,790
जो एक और अधिक उन्नत एन्क्रिप्शन तकनीक है.

34
00:02:01,790 --> 00:02:05,640
और इसलिए हम पाठ का एक टुकड़ा कूटलेखन जा रहे हैं,

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
ठीक है, तो toolbox में आज पहली उपकरण वास्तव में उपकरण को अद्यतन किया जा रहा है.

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
और अक्सर समाधान वास्तव में सिर्फ अपने उपकरण अद्यतन.

41
00:02:31,830 --> 00:02:36,730
और यदि ऐसा है तो आप सिर्फ अपने उपकरण sudo yum-y में एक टर्मिनल विंडो में चलाने -

42
00:02:36,730 --> 00:02:40,040
कि हाँ कह झंडा है, सब कुछ अद्यतन अद्यतन,

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
और फिर हम arrays और तार, जो हम एक बहुत का उपयोग कर के रूप में अच्छी तरह से हो जाएगा में जाना होगा.

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
जोड़ने, उन्हें subtracting तो निश्चित रूप से इस चार्ट का उल्लेख करने के लिए अच्छा है.

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
अनिवार्य रूप से, एक साथ गठबंधन किया है, बी बी के साथ गठबंधन किया है, जेड के लिए सभी तरह से ऊपर

82
00:05:21,540 --> 00:05:26,590
लेकिन तब हम कहते हैं कि हम 3 की एक प्रमुख उदाहरण के लिए चाहता था,.

83
00:05:26,590 --> 00:05:33,280
तो फिर हम भीतरी पहिया बारी बारी से इतना है कि अब एक डी, आदि के साथ aligns

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
यदि हम हमारे सीज़र सिफर में एक एल से पत्र में प्रवेश किया है,

95
00:06:14,550 --> 00:06:19,520
तो यह हे के माध्यम से डी इनपुट है कि क्योंकि हर 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
और कि दोनों सीज़र और Vigenere में एक महत्वपूर्ण बात है

100
00:06:31,040 --> 00:06:34,890
यह है कि हम किसी भी गैर - पत्र को छोड़ जा रहे हैं.

101
00:06:34,890 --> 00:06:39,160
तो किसी भी स्थान, वर्ण, आदि, संख्या, हम उन्हें एक ही रखने के लिए जा रहे हैं.

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
और इसलिए हम किसी भी तरह यह 2 कमांड लाइन तर्क होने जा रहा है देखना चाहता हूँ.

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
चलो एक छोटा सा arrays के बारे में बात करते हैं.

120
00:08:03,990 --> 00:08:05,940
Arrays अनिवार्य रूप से एक नया डेटा संरचना हैं.

121
00:08:05,940 --> 00:08:09,660
हम ints हम डबल्स है, हम तार है, और अब हम arrays है.

122
00:08:09,660 --> 00:08:13,820
Arrays डेटा संरचनाओं कि एक ही प्रकार के कई मूल्यों को पकड़ कर सकते हैं,

123
00:08:13,820 --> 00:08:18,320
इसलिए अनिवार्य रूप से, आप चाहते हैं जो कुछ भी प्रकार की एक सूची है.

124
00:08:18,320 --> 00:08:24,400
अनिवार्य रूप से, अगर आप एक चर में सभी integers की एक सूची चाहता था,

125
00:08:24,400 --> 00:08:29,090
तो आप एक नया चर कि प्रकार int सरणी था पैदा होगा.

126
00:08:29,090 --> 00:08:34,450
तो arrays शून्य अनुक्रमित कर रहे हैं, जिसका अर्थ है कि सरणी के पहले तत्व 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
ध्यान दें कि हम कभी arrays में लंबाई नहीं बदल सकते हैं,

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
आप मेलबॉक्स सूचकांक शून्य 1.2 पर निर्धारित किया जाएगा,

142
00:09:37,620 --> 00:09:42,180
मेलबॉक्स सूचकांक 1 2.4 करने के लिए सेट, आदि

143
00:09:42,180 --> 00:09:47,910
तो अब है कि हम arrays एक बिट की समीक्षा की है, चलो 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
वे कहते हैं. / हैलो डेविड Malan,

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
इस मामले में argc 3 हो सकता है क्योंकि यह 3 अलग स्थानों के द्वारा पृथक शब्दों देखता होगा.

150
00:10:14,370 --> 00:10:18,850
और यदि ऐसा है तो फिर इस उदाहरण में सरणी, पहली सूचकांक / नमस्ते होगा,

151
00:10:18,850 --> 00:10:21,770
अगले एक डेविड, अगले एक Malan.

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
गुण के लिए जाना है, साथ खुला, और तो जीएडिट, डिफ़ॉल्ट के रूप में सेट चुनते हैं,

160
00:11:04,580 --> 00:11:13,020
और अब अपने कार्यक्रम के बजाय जीएडिट 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
तो एक संरचना है कि हम पर कुछ पुनरावृति का उपयोग कर सकते हैं क्या है -

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 के लिए है. चलो बस एक मानक initialization चर के साथ शुरू करते हैं.

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 में प्रत्येक तत्व पुनरावृति करना चाहते हैं,

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 inputted, मैं इसे आप को वापस देने के लिए जा रहा हूँ."

198
00:14:18,320 --> 00:14:23,170
तो चलो कहते हैं कि हम args तो foo बार कहना चाहता हूँ.

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
सुनिश्चित करें कि आप कभी arrays का उपयोग एक साथ सरणी की लंबाई से परे नहीं है

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
कि सरणी सूचकांक 4 क्योंकि हम 0 में शुरू शून्य सूचकांक में मौजूद नहीं है.

210
00:15:07,240 --> 00:15:11,730
Loops के लिए यह दूसरी प्रकृति की तरह ही हो जब हम 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
तो यह वास्तव में अभी तक है, एक पूर्णांक नहीं लेकिन सीज़र में हम integers के साथ सौदा करना चाहते हैं.

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
[छात्र] आप 2 की आवश्यकता क्यों है के रूप में सिर्फ 1 argc विरोध? वहाँ निश्चित रूप से 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 और तो फिर हम एक अतिरिक्त inputting रहे हैं.

246
00:17:45,030 --> 00:17:49,440
तो आप वास्तव में कमांड लाइन तर्क में एक स्ट्रिंग inputting रहे हैं.

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
तो शुरुआत में हम एक हैश की तरह है कि टैग मानक कुछ मैं / हे, ज, के साथ शुरू करते हैं.

254
00:18:19,450 --> 00:18:22,430
खैर, atoi उन पुस्तकालयों के भीतर नहीं है,

255
00:18:22,430 --> 00:18:26,600
तो हमें क्या करना है क्या है हम उस के लिए सही पुस्तकालय शामिल है.

256
00:18:26,600 --> 00:18:32,720
तो 1 Walkthrough जहां मैं मैनुअल कार्य पर विचार - विमर्श करने के लिए याद करते हैं.

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
लेकिन इस मामले में हम किसी भी do करने की जरूरत नहीं है, जबकि या जबकि loops की जांच करने के लिए.

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
तो आप कल्पना कर सकते हैं है कि इन उपयोगकर्ता inputted तार के सभी सही हैं.

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
अब क्या बचा है आप plaintext कूटलेखन है.

273
00:19:31,660 --> 00:19:36,530
बस जल्दी शब्दावली पर कवर करने के लिए, plaintext उपयोगकर्ता तुम क्या देता है,

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
और इसलिए हम क्योंकि वे पात्रों के arrays arrays के रूप में तार का इलाज कर सकते हैं.

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 सूचकांक में पाठ एक राजधानी टी होगा, सूचकांक 1 घंटे, आदि होगा

284
00:20:17,530 --> 00:20:23,970
और फिर arrays के साथ, argc args.c में उदाहरण में,

285
00:20:23,970 --> 00:20:27,090
हमने देखा है कि हम पर एक सरणी पुनरावृति था

286
00:20:27,090 --> 00:20:32,440
और इसलिए हम से पुनरावृति = 0 मैं जब तक मैं लंबाई से भी कम है.

287
00:20:32,440 --> 00:20:35,560
तो हम बाहर लगाना हमारे स्ट्रिंग की लंबाई क्या है की किसी तरह की जरूरत है

288
00:20:35,560 --> 00:20:37,090
अगर हम यह अधिक पुनरावृति करने के लिए जा रहे हैं.

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
कैसे हम एक स्ट्रिंग में प्रत्येक चरित्र पुनरावृति करने में सक्षम हो सकता है की एक उदाहरण देखो

295
00:21:05,840 --> 00:21:08,470
और उस के साथ कुछ करना है.

296
00:21:08,470 --> 00:21:13,250
हम क्या करना चाहते है पर स्ट्रिंग के प्रत्येक चरित्र पुनरावृति,

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
हम पुनरावृति करना चाहते हैं जब तक हम स्ट्रिंग के अंत तक पहुँचते हैं, है ना?

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
तो फिर इस मामले में हम स्ट्रिंग है के साथ काम कर रहे हैं.

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
जब आप इसे एक नाव बाहर मुद्रित करने के लिए करना चाहते हैं, तो आप% च की तरह प्लेसहोल्डर का प्रयोग करेंगे.

314
00:22:22,150 --> 00:22:24,580
एक int के साथ आप% d का उपयोग होगा.

315
00:22:24,580 --> 00:22:30,890
और अब इसी तरह, एक चरित्र के साथ आप% ग का उपयोग करने के लिए कहते हैं कि मैं एक चरित्र मुद्रण किया जा रहा हूँ

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
तो अगर एक स्ट्रिंग एक सरणी है, तो हम कैसे arrays के तत्वों का उपयोग करते हैं?

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
इससे पहले, हम एक int कैसे मिला?

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
हम कैसे हम एक स्ट्रिंग पर पुनरावृति पर कुछ उपकरण है,

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
तो यहाँ कहना है कि हमारे plaintext मुझे चक्कर आ रहा हूँ!

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
तो plaintext की 1 सूचकांक में अगले अक्षर लोप या सम्बन्ध का चिह्न होगा.

355
00:25:40,960 --> 00:25:46,780
लेकिन याद रखना हम केवल पत्र सांकेतिक शब्दों में बदलना चाहते हैं.

356
00:25:46,780 --> 00:25:50,040
इसलिए हम यह सुनिश्चित करें कि apostrophe वास्तव में एक ही रहता है बनाना चाहते हैं,

357
00:25:50,040 --> 00:25:54,310
कि हम 39 से 45 जो कुछ भी परिवर्तन नहीं है.

358
00:25:54,310 --> 00:25:57,150
हम इसे एक apostrophe के रूप में रखना चाहते हैं.

359
00:25:57,150 --> 00:26:00,780
तो हम करने के लिए केवल अक्षर कूटलेखन याद रखना चाहते हैं

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
या तो कुछ नहीं कूटलेखन है या यह बीजलेख या सुनिश्चित करें कि यह अपरकेस, आदि है

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
लेकिन हम यह सुनिश्चित करें कि कि हे एक राजधानी ओ होने जा रहा है बनाना चाहते हैं

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
हम क्या हम उपयोग निहित कास्टिंग की तरह है.

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 के साथ हम तरह का interchangeably वर्णों का उपयोग करने के लिए सक्षम हो जाएगा

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 से संबंधित है. लोअरकेस च 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
कैसे आप वास्तव में वास्तव में इन पात्रों के साथ काम कर सकते हैं, उन्हें interchangeably उपयोग करें.

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
जब से मैं मांग रहा हूँ कि वे मुझे एक बात दे रहे हैं,

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
तो मैं कह रहा हूँ कुंजी के लिए 1 कमांड लाइन तर्क नहीं जा रहा है,

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
जिस तरह से है कि मैं एक पूर्णांक के रूप में आर का उपयोग करने में सक्षम हूँ यह इन एकल उद्धरण के साथ 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
ओह देखते हैं, लेकिन यह कुछ भी नहीं है क्योंकि हम वास्तव में यह एक कुंजी नहीं दिया था करता है.

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 हमें v, जो 118 के ASCII मान से मेल खाती है देने के लिए जा रहा है की वृद्धि हुई.

430
00:31:39,280 --> 00:31:43,880
तो फिर यह किस तरह का है कि समझ में आता है -

431
00:31:43,880 --> 00:31:51,250
दरअसल, मैं आप से पूछना कर सकते हैं, आप क्या सोचते हैं आर के ASCII मान है अगर + r 4 118 है?

432
00:31:53,070 --> 00:31:55,470
हाँ फिर, आर 114 है.

433
00:31:55,470 --> 00:32:03,010
तो अगर आप ASCII तालिका पर लग रही है, तो यकीन है कि पर्याप्त है, आप देखेंगे कि r 114 द्वारा प्रतिनिधित्व किया है.

434
00:32:03,010 --> 00:32:08,610
तो अब है कि हम जानते हैं कि हम integers वर्ण को जोड़ सकते हैं, यह बहुत आसान लगता है.

435
00:32:08,610 --> 00:32:12,740
हम सिर्फ एक स्ट्रिंग पुनरावृति जैसे हम एक पहले उदाहरण में देखा जा रहे हैं.

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
आप वापस ए के लिए सभी तरह लपेट चाहते हैं

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
मूलतः, जब आप एक्स modulo y, कि आप 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 ने कहा, लेकिन हम वास्तव में आप 1 कहने के लिए चाहते हैं, क्योंकि हम केवल 3 समूहों चाहते हैं.

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
खैर, 4 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 3 आधुनिक 2 है.

475
00:34:53,760 --> 00:34:59,100
मैं देखने के लिए कितने 3 के समूह पर छोड़ दिया है, तो जो मैं कर रहा हूँ

476
00:34:59,100 --> 00:35:02,860
और अगर ऐसा हो तो हम पूरे कमरे के साथ जारी रखा,

477
00:35:02,860 --> 00:35:07,760
तो हमें देखना होगा कि हम वास्तव में हमेशा रहे हैं और खुद को आधुनिक समारोह लागू

478
00:35:07,760 --> 00:35:09,990
तरह की गिनती.

479
00:35:09,990 --> 00:35:14,490
कि कैसे आप modulo का उपयोग हो सकता है के ठोस उदाहरण के एक अधिक तरह है

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
Modulo पर कोई सवाल?

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
यदि उनमें से 1 3 में से एक यह किया था, यह उन्हें दिया होता है कि वे क्या वास्तव में थे,

487
00:35:40,430 --> 00:35:43,310
या उन्हें दिया होता है [अश्राव्य] >> यह एक अच्छा सवाल है.

488
00:35:43,310 --> 00:35:48,750
जब वहाँ modulo लिए कोई शेष है तो कहते हैं कि आप 6 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 3 आधुनिक वास्तव में है 0, लेकिन वह 3 कहा.

492
00:36:07,720 --> 00:36:14,900
तो यह है कि एक आंतरिक पकड़ की तरह की तरह है, उदाहरण के लिए,

493
00:36:14,900 --> 00:36:17,620
ठीक तरह, अगर आधुनिक 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
plaintext के ith चरित्र के अनुरूप रहा है.

505
00:37:02,500 --> 00:37:08,130
यही समझ में आता है क्योंकि हम हमेशा इन चीजों को अस्तर होना चाहता हूँ.

506
00:37:08,130 --> 00:37:13,480
तो यह सिफर प्लस कश्मीर, जो हमारे मुख्य है ith चरित्र होने जा रहा है -

507
00:37:13,480 --> 00:37:17,230
कि समझ में आता है और फिर हम इस 26 आधुनिक है.

508
00:37:17,230 --> 00:37:19,860
वापस याद है जब हम जेड था

509
00:37:19,860 --> 00:37:24,190
हम चरित्र में नहीं चाहता था, इसलिए हम यह आधुनिक चाहता था

510
00:37:24,190 --> 00:37:26,540
वर्णमाला के आसपास और रैप की तरह.

511
00:37:26,540 --> 00:37:33,430
जेड के बाद आप एक के लिए जाना होगा, ख, ग, घ, जब तक आप सही संख्या के लिए मिला है.

512
00:37:33,430 --> 00:37:44,690
इसलिए हम जानते हैं कि जेड, अगर 6 +, हमें च दे क्योंकि बाद जेड एक, च बी, सी, डी, ई, आता होगा.

513
00:37:44,690 --> 00:37:52,530
तो चलो याद है हम यकीन के लिए पता है कि जेड + 6 हमें च दे रहा है.

514
00:37:52,530 --> 00:38:03,530
ASCII मूल्यों में, जेड 122 और च 102 है.

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
तो अगर हम सिर्फ इस सूत्र, ('Z 6 +) 26%, कि वास्तव में आप 24 देता लागू

518
00:38:19,550 --> 00:38:25,980
क्योंकि 122 + 6 128, 128 26% शेष 24 देता है.

519
00:38:25,980 --> 00:38:29,140
लेकिन वह वास्तव में च मतलब नहीं है. यह निश्चित रूप से 102 नहीं है.

520
00:38:29,140 --> 00:38:33,590
यह भी वर्णमाला में 6 अक्षर नहीं है.

521
00:38:33,590 --> 00:38:41,550
तो जाहिर है, हम यह एक थोड़ा tweaking का कोई रास्ता है की जरूरत है.

522
00:38:42,970 --> 00:38:51,340
नियमित वर्णमाला के संदर्भ में, हम जानते हैं कि z 26 पत्र और च 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 25 + 6 से प्रतिनिधित्व किया है, जो आप 31 देता है.

528
00:39:11,710 --> 00:39:15,790
और 31 26 आधुनिक आप एक के रूप में शेष 5 देता है.

529
00:39:15,790 --> 00:39:20,500
यह बिल्कुल सही है क्योंकि हम जानते हैं कि वर्णमाला में 5 पत्र है.

530
00:39:20,500 --> 00:39:26,400
लेकिन यह अभी भी च, सही नहीं है? यह अभी भी 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
हम कमांड लाइन तर्क से हमारे कुंजी मिल गया है, हम plaintext मिल गया है,

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
, के रूप में हम पर स्ट्रिंग में वर्णों पुनरावृति

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
और अंत में है कि पूरी सरणी पर पुनरावृति और इसे बाहर प्रिंट.

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
इसलिए हम सीज़र है, और अब हम Vigenere पर स्थानांतरित करने के लिए,

551
00:40:50,420 --> 00:40:57,580
जो बहुत सीज़र के समान है लेकिन बस थोड़ा और अधिक जटिल है.

552
00:40:57,580 --> 00:41:03,310
तो Vigenere के साथ अनिवार्य रूप से आप एक कीवर्ड में पारित हो जा रहे हैं.

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
और तो यह सांकेतिक शब्दों में बदलना और फिर उन्हें सिफर वापस दे.

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
शायद खोजने के लिए या अपने खुद के ASCII तालिका है कि 25 के माध्यम से 0 की वर्णमाला अनुक्रमणिका से पता चलता है,

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
इसी तरह, अगर आप कुछ उदाहरण में च द्वारा जा रहे थे -

568
00:42:11,010 --> 00:42:21,110
और यह भी लोअरकेस या अपरकेस च है - तो यह है कि 5 के अनुरूप होगा.

569
00:42:21,110 --> 00:42:24,180
क्या हम अब तक तो अच्छा है?

570
00:42:25,770 --> 00:42:30,050
Vigenere के लिए एक अलग सा सूत्र है.

571
00:42:30,050 --> 00:42:32,960
असल में, आप देखते हैं कि यह बस सीज़र की तरह है,

572
00:42:32,960 --> 00:42:37,390
के बजाय सिर्फ कश्मीर को छोड़कर हम कश्मीर सूचकांक 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
और हम केवल कूटलेखन, वर्ण या स्थान नहीं पत्र.

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
हम एक plaintext कि हम उपयोगकर्ता से 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
1 4 अक्षर बहुत आसान है.

589
00:43:50,930 --> 00:43:55,580
हम जानते हैं कि टी ओ द्वारा स्थानांतरित किया जा रहा है,

590
00:43:55,580 --> 00:44:01,990
तो ज ज द्वारा स्थानांतरित किया जा रहा है, मैं करने के लिए एक से स्थानांतरित किया जा रहा है.

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
फिर एस मैं द्वारा स्थानांतरित कर दिया है.

594
00:44:15,250 --> 00:44:19,370
लेकिन फिर आप इन अवधियों यहाँ है.

595
00:44:19,370 --> 00:44:25,960
हम कूटलेखन कि, यदि ऐसा है तो फिर हम इसे से कुछ भी नहीं बदल सकता हूँ नहीं करना चाहती

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
[छात्र] तो ओ को ही स्थानांतरित हो जा रहा है -

602
00:44:52,020 --> 00:44:56,260
ओ तो वर्णमाला में एक निश्चित संख्या से मेल खाती है.

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 का उपयोग करने के लिए और अधिक पुनरावृति करने के लिए जा रहे हैं.

613
00:45:32,090 --> 00:45:38,200
सूचना है कि हम यहाँ encrypting अवधि पर छोड़ दिया,

614
00:45:38,200 --> 00:45:51,660
लेकिन हमारी स्थिति के ohai, अगले एक के लिए संदर्भ में हम ओ का इस्तेमाल किया.

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
फिर हम और मैं है, जो तब ओ और घंटे के द्वारा क्रमशः अनुवादित है.

618
00:46:02,960 --> 00:46:09,370
तो फिर हम एक जगह है, और इतना तो हम जानते हैं कि हम के लिए रिक्त स्थान कूटलेखन के लिए नहीं जा रहे हैं.

619
00:46:09,370 --> 00:46:18,930
लेकिन सूचना है कि इस जगह में एक यहीं पर जाने की बजाय,

620
00:46:18,930 --> 00:46:28,330
हम एक से encrypting रहे हैं - सही यहाँ मैं अगर आपको लगता है कि देख सकते हैं पता नहीं.

621
00:46:28,330 --> 00:46:33,710
तो आप वास्तव में पूर्व निर्धारित इसे पसंद नहीं है, कहते हैं, ओ यहाँ जाता है, ज यहाँ जाता है,

622
00:46:33,710 --> 00:46:39,200
यहाँ एक हो जाता है, मैं यहाँ जाता है, ओ, ज, एक, मैं, ओ, ज, मैं एक. आप ऐसा नहीं करते.

623
00:46:39,200 --> 00:46:43,760
आप केवल कीवर्ड में अपनी स्थिति में बदलाव

624
00:46:43,760 --> 00:46:51,020
जब आप जानते हैं कि आप वास्तव में एक वास्तविक पत्र encrypting हो जा रहे हैं.

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
अगर आपके plaintext में चरित्र एक पत्र है.

630
00:47:06,390 --> 00:47:09,120
तो हम कहते हैं कि हम ओ हो.

631
00:47:09,120 --> 00:47:19,310
हमने देखा है कि अगले चरित्र, plaintext की मैं सूचकांक, उदाहरण के लिए, एक संख्या है.

632
00:47:19,310 --> 00:47:31,630
तो हम जम्मू, हमारे खोजशब्द के लिए सूचकांक अग्रिम नहीं है, जब तक हम एक पत्र तक पहुँचने.

633
00:47:31,630 --> 00:47:36,230
फिर, तुम भी कीवर्ड की शुरुआत करने के लिए सुनिश्चित करें कि आप wraparound बनाना चाहते हैं

634
00:47:36,230 --> 00:47:37,770
जब आप इसे के अंत में कर रहे हैं.

635
00:47:37,770 --> 00:47:42,030
यदि आप देखते हैं यहाँ हम मैं कर रहे हैं, अगले एक ओ हो गया है.

636
00:47:42,030 --> 00:47:47,690
तो आप अपने कीवर्ड की शुरुआत करने के लिए wraparound करने में सक्षम होने का कोई रास्ता मिल चाहते हैं

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
तो modulo काम में यहाँ आते हैं जब आप अपने 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
उनकी संख्या है कि उन्होंने कहा कि 4 3 आधुनिक, जो 1 था था.

645
00:48:30,610 --> 00:48:32,880
तो कोशिश करते हैं और यह सोचने के लिए कि जिस तरह से.

646
00:48:34,770 --> 00:48:42,740
जैसा कि आप सूत्र में देखा, जहाँ भी तुम ci और pi तो है, लेकिन फिर के.जे.,

647
00:48:42,740 --> 00:48:44,700
आप सुनिश्चित करें कि आप उन का ट्रैक रखने बनाना चाहते.

648
00:48:44,700 --> 00:48:47,580
आप यह मैं फोन करने की जरूरत नहीं है, तो आप यह जम्मू के फोन करने की जरूरत नहीं है,

649
00:48:47,580 --> 00:48:53,270
लेकिन आप यह सुनिश्चित करें कि आप अपने plaintext में स्थिति यह है कि आप कर रहे हैं ट्रैक रखने बनाना चाहते हैं

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
न केवल कीवर्ड करता है - यह अपने plaintext की तुलना में एक पूरी तरह से अलग लंबाई हो सकता है.

653
00:49:06,400 --> 00:49:09,140
इसके अलावा, अपने plaintext, संख्या और अक्षर हैं,

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
interchangeably 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
"मैं क्योंकि इस पद्धति का उपयोग कर रहा है ..." और किस तरह का पैटर्न succinctly समझा अपनी टिप्पणी में.

676
00:50:54,090 --> 00:50:58,990
[इस 2 walkthrough] अगर कोई अन्य सवाल नहीं कर रहे हैं, तो मैं सिर्फ एक छोटा सा के लिए यहाँ रहना होगा.

677
00:50:58,990 --> 00:51:04,370
क्रिप्टो और आने के लिए धन्यवाद: 2 pset के साथ गुड लक.

678
00:51:06,070 --> 00:51:08,620
[छात्र] धन्यवाद. >> धन्यवाद.

679
00:51:09,220 --> 00:51:10,800
[मीडिया ऑफ़लाइन परिचय]