1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] धारा समस्या 2 सेट: हैकर संस्करण

2
00:00:02,670 --> 00:00:04,910
रोब Bowden, हार्वर्ड विश्वविद्यालय

3
00:00:04,910 --> 00:00:07,410
यह CS50 है. CS50.TV

4
00:00:07,410 --> 00:00:15,770
तो, मैं रोब हूँ. मैं एक वरिष्ठ Kirkland में हूँ. यह मेरी 3 CS50 TFing वर्ष है.

5
00:00:15,770 --> 00:00:22,220
यह पहली बार है कि हम परंपरागत व्याख्यान शैली अनुभाग से बदल रहे हैं,

6
00:00:22,220 --> 00:00:25,610
जहां हम समीक्षा के बस की तरह व्याख्यान में क्या हुआ और फिर तुम लोगों को सवालों के पूछने,

7
00:00:25,610 --> 00:00:32,250
अब एक बहुत अधिक समस्या आधारित किया जा रहा है, जहां हम रिक्त स्थान का उपयोग करने के लिए, और

8
00:00:32,250 --> 00:00:37,410
ओह, तो विचार है कि लिंक मैं तुम्हें भेजा जाना है और फिर आप अपने अंतरिक्ष में हो जाएगा.

9
00:00:37,410 --> 00:00:42,410
क्या किसी एक लैपटॉप भी नहीं है? ठीक है.

10
00:00:42,410 --> 00:00:47,050
तो हम इस का उपयोग किया जा रहे हैं, और हम समस्याओं कर रही हो जा रहे हैं अनुभाग में रहते हैं

11
00:00:47,050 --> 00:00:50,740
और उन पर चर्चा और पता लगाना है कि क्या गलत है

12
00:00:50,740 --> 00:00:56,390
और मैं अपने कोड के कुछ खींचने के लिए, हो सकता है और मैं अपने विचारों पर चर्चा हो सकती है.

13
00:00:56,390 --> 00:01:02,140
इसलिए किसी को भी कठिनाई पड़ा है?

14
00:01:02,140 --> 00:01:07,000
आप पक्ष पर चैट कर सकते हैं, मैं अगर हम उस के लिए कारण हो जाएगा पता नहीं है.

15
00:01:07,000 --> 00:01:12,270
अब, पिछले supersection की तरह, अगर आपको लगता है कि वर्ग में थे, तो आप जानते हैं कि किस बारे में है.

16
00:01:12,270 --> 00:01:19,200
पी सेट के सभी पर इन वर्गों को होने जा रहा है.

17
00:01:19,200 --> 00:01:22,550
तो पी 2 सेट, विनिर्देशों, मुझे लगता है कि आप 1 पी सेट पर यह पहले से ही देखा है.

18
00:01:22,550 --> 00:01:27,400
लेकिन हम पी 2 सेट पर क्या हम आज पर जा रहा जा रहे हैं के लिए देख सकते हैं.

19
00:01:27,400 --> 00:01:29,460
और तुम सवालों का एक अनुभाग देखेंगे.

20
00:01:29,460 --> 00:01:37,530
तो यह सब पी सेट में होगा, वहाँ सवालों की एक खंड हो जाएगा.

21
00:01:37,530 --> 00:01:41,340
अब तक हम कहा है, "एक अभ्यास का मौका इस पर विचार करें."

22
00:01:41,340 --> 00:01:44,940
आप इस कार्यक्रम प्रस्तुत करने के लिए नहीं कहा जाएगा.

23
00:01:44,940 --> 00:01:48,480
विचार यह है कि इन की मदद से आप समस्या सेट के साथ शुरू करने के लिए की तरह करने के लिए चाहिए रहे हैं.

24
00:01:48,480 --> 00:01:53,220
मैं हैकर संस्करण पर लगता है, उनमें से एक बहुत कुछ करने के लिए सिर्फ नए, दिलचस्प बातें सीखने को होना चाहिए रहे हैं.

25
00:01:53,220 --> 00:01:58,590
वे सीधे समस्या सेट करने के लिए लागू नहीं हो सकता.

26
00:01:58,590 --> 00:02:01,810
और अब हम कर आप उन्हें प्रस्तुत नहीं कर रहे हैं, लेकिन सिद्धांत रूप में,

27
00:02:01,810 --> 00:02:07,480
बाद में समस्या के सेट के लिए, आप उन्हें प्रस्तुत करने के लिए, और हो सकता है इस प्रकार आप या तो अनुभाग के लिए आ सकते हैं

28
00:02:07,480 --> 00:02:10,380
या अनुभाग देखने के लिए जवाब मिलता है, या आप बस उन्हें अपने दम पर प्राप्त कर सकते हैं

29
00:02:10,380 --> 00:02:16,350
अगर आप मेरी उपस्थिति का आनंद ले की तरह महसूस नहीं करते.

30
00:02:16,350 --> 00:02:21,010
तो मुझे लगता है कि यह पहली एक है.

31
00:02:21,010 --> 00:02:29,280
ओह. इसके अलावा, सवालों के इन वर्गों के तहत हम भी आप शॉर्ट्स के बारे में सवाल पूछना है.

32
00:02:29,280 --> 00:02:33,440
तो मुझे लगता है, सिद्धांत रूप में, आप अनुभाग के लिए आने से पहले इन देखने के लिए चाहिए रहे हैं,

33
00:02:33,440 --> 00:02:38,550
लेकिन यह ठीक है अगर आप नहीं करते हैं, हम उन पर वैसे भी जाना होगा.

34
00:02:38,550 --> 00:02:42,590
इसलिए हम इन के साथ शुरू कर सकते हैं: "एक समय पाश है, जबकि एक पाश से कैसे भिन्न होता है?

35
00:02:42,590 --> 00:02:46,210
बाद जब विशेष रूप से उपयोगी है? "

36
00:02:46,210 --> 00:02:49,390
तो किसी को भी किसी भी है?

37
00:02:49,390 --> 00:02:52,730
[छात्र] है, जबकि पाश हमेशा कम से कम एक बार अमल करेंगे.

38
00:02:52,730 --> 00:03:02,950
हां. तो यह है कि अंतर है. जबकि पाश - I'll सिर्फ इसे यहाँ पर करते हैं जबकि पाश, हम शर्त है

39
00:03:02,950 --> 00:03:19,760
यहीं, जबकि करते, जबकि आप एक शर्त नहीं है जब तक हम यहाँ नीचे जाओ.

40
00:03:19,760 --> 00:03:24,130
और हां, जब अपने कार्यक्रम को क्रियान्वित करने, और यह जबकि पाश के लिए हो जाता है,

41
00:03:24,130 --> 00:03:26,380
इसे तुरंत जाँच करता है अगर यह शर्त सही है.

42
00:03:26,380 --> 00:03:30,710
यदि उस हालत सही नहीं है, यह बस पर पाश पूरी तरह से छोड़ जाएगा.

43
00:03:30,710 --> 00:03:34,390
मत जबकि पाश, के रूप में कार्यक्रम को क्रियान्वित कर रहा है, यह करने के लिए "क्या." हो जाता है

44
00:03:34,390 --> 00:03:37,920
इस बिंदु पर कुछ भी नहीं होता है, बस निष्पादित कर जारी है.

45
00:03:37,920 --> 00:03:42,690
फिर जब यह "जबकि," हिट अगर हालत सच है, यह पाश वापस करने के लिए और इसे फिर से करना होगा

46
00:03:42,690 --> 00:03:46,730
और फिर जब तक शर्त सही और फिर बस के माध्यम से गिर जाता है नहीं है.

47
00:03:46,730 --> 00:03:50,600
तो, अंतर किया जा रहा है, कि यह सही बहुत प्रारंभ से ही छोड़ सकते हैं.

48
00:03:50,600 --> 00:03:56,770
यह जरूरी एक बार निष्पादित करता है और फिर से अधिक बार निष्पादित अगर हालत अभी भी सच हो सकता है.

49
00:03:56,770 --> 00:04:03,720
तो, जबकि पाश केवल इसे एक बार करना होगा, या जबकि पाश - हम यह सब करने की जरूरत नहीं हो सकती है,

50
00:04:03,720 --> 00:04:07,900
जैसे ही हम इसे पाने के लिए के बाद से, अगर हालत झूठी है, हम सिर्फ यह खत्म सही छोड़ देंगे.

51
00:04:07,900 --> 00:04:11,770
जबकि जबकि पाश, हम इसे एक बार निष्पादित, अनिवार्य.

52
00:04:11,770 --> 00:04:14,560
तब, जब हम शर्त करने के लिए मिलता है, हम जांच अगर यह सही है या गलत है.

53
00:04:14,560 --> 00:04:19,790
अगर यह सच है, तो हम इसे फिर से करूँगा, अगर यह गलत है, हम बस जा रही जारी रखेंगे.

54
00:04:19,790 --> 00:04:24,680
तो जब बाद विशेष रूप से उपयोगी है?

55
00:04:24,680 --> 00:04:31,190
तो मैं 4 साल की संपूर्णता, 3 साल, जो कुछ भी कह सकते हैं कि,

56
00:04:31,190 --> 00:04:38,780
कि मैं प्रोग्रामिंग किया गया है, मैं इस का इस्तेमाल किया है, जैसे 10 गुना के तहत.

57
00:04:38,780 --> 00:04:43,140
और शायद उनमें से 5 CS50 में कर रहे हैं जब हम करते हैं, जबकि loops शुरू कर रहे हैं.

58
00:04:43,140 --> 00:04:47,510
तो जब आप करते हैं, जबकि loops इस्तेमाल करते हैं?

59
00:04:47,510 --> 00:04:49,510
हाँ -?

60
00:04:49,510 --> 00:04:53,180
[छात्र] जब आप उपयोगकर्ता इनपुट, या कुछ और आप की जाँच करना चाहते हैं पाने के लिए कोशिश कर रहे हैं -

61
00:04:53,180 --> 00:04:59,700
हाँ. तो क्या, जबकि loops, उपयोगकर्ता इनपुट एक बड़ा है.

62
00:04:59,700 --> 00:05:03,160
कि पहली जोड़ी समस्या सेट पर क्यों है, जब आप उपयोगकर्ता पूछने की तरह करना चाहते हैं,

63
00:05:03,160 --> 00:05:08,520
उन्होंने कहा, "मुझे एक स्ट्रिंग दे" आप जब तक आप उस स्ट्रिंग प्राप्त नहीं जारी रख सकते हैं.

64
00:05:08,520 --> 00:05:12,980
और इसलिए तुम जरूरी स्ट्रिंग के लिए कम से कम एक बार पूछने की जरूरत है.

65
00:05:12,980 --> 00:05:16,950
लेकिन फिर अगर वे कुछ बुरा का जवाब है, तो आप वापस पाश के लिए की जरूरत है और फिर से पूछो.

66
00:05:16,950 --> 00:05:20,810
लेकिन उपयोगकर्ता इनपुट के अलावा, यह बहुत दुर्लभ है कि मैं एक मामले में मुठभेड़

67
00:05:20,810 --> 00:05:27,170
जहाँ मैं पाश के लिए "कम से कम एक बार" करना चाहते हैं, लेकिन संभवतः अधिक.

68
00:05:27,170 --> 00:05:33,370
प्रश्न या? किसी को भी एक है, जबकि पाश कहीं और इस्तेमाल किया?

69
00:05:33,370 --> 00:05:36,780
ठीक है. तो अगले एक है, "क्या पहचानकर्ता अघोषित करता है

70
00:05:36,780 --> 00:05:43,310
आम तौर पर अगर बजना द्वारा outputted संकेत मिलता है? "

71
00:05:43,310 --> 00:05:47,380
तो किस तरह के कोड का मैं लिख सकता है 'अघोषित पहचानकर्ता?'

72
00:05:47,380 --> 00:05:49,550
[छात्र] कि x = 2?

73
00:05:49,550 --> 00:05:52,650
तो हम बस इसे यहाँ की कोशिश कर सकते हैं, x = 2.

74
00:05:52,650 --> 00:06:04,830
हम इस चला हूँ - ओह, मैं इसे क्लिक नहीं किया. सब ठीक तो यहाँ हम मिलता है.

75
00:06:04,830 --> 00:06:07,100
"अघोषित पहचानकर्ता एक्स का प्रयोग करें."

76
00:06:07,100 --> 00:06:11,610
तो यह है कि अघोषित पहचानकर्ता, एक चर है.

77
00:06:11,610 --> 00:06:13,910
यह अक्सर एक चर एक पहचानकर्ता कॉल जाएगा.

78
00:06:13,910 --> 00:06:17,300
तो यह पता है कि यह वास्तव में एक चर नहीं हो सकता है, यह पता नहीं है कि यह क्या है.

79
00:06:17,300 --> 00:06:19,380
तो यह एक पहचानकर्ता है.

80
00:06:19,380 --> 00:06:26,060
क्यों तो यह अघोषित है? हाँ.

81
00:06:26,060 --> 00:06:32,190
तो शब्दावली, एक चर की घोषणा पर स्पष्ट होने के लिए

82
00:06:32,190 --> 00:06:37,360
जब आप "int x," या "स्ट्रिंग y," जो कुछ भी कहते हैं.

83
00:06:37,360 --> 00:06:41,910
चर चर के या असाइनमेंट के initialization,

84
00:06:41,910 --> 00:06:44,510
जब भी आप कहते हैं कि "x = 2 है."

85
00:06:44,510 --> 00:06:52,950
तो हम अलग - अलग चरणों में इन कर सकते हैं, int x, x = 2, और जब तक हम यहाँ में सामान की एक गुच्छा हो सकता है -

86
00:06:52,950 --> 00:07:00,350
लेकिन जब तक इस लाइन होता है, एक्स अभी भी, uninitialized है लेकिन यह घोषित किया गया है.

87
00:07:00,350 --> 00:07:06,760
और इसलिए हम स्पष्ट रूप से यह एक लाइन में कर सकते हैं, और अब हम की घोषणा कर रहे हैं और आरंभ करने के दौरान.

88
00:07:06,760 --> 00:07:10,730
प्रश्न?

89
00:07:10,730 --> 00:07:18,390
और अंत में, "सीज़र छद्मकरण क्यों बहुत सुरक्षित नहीं है?"

90
00:07:18,390 --> 00:07:23,830
तो पहले किसी को कहना सीज़र छद्मकरण क्या है चाहता है?

91
00:07:23,830 --> 00:07:28,100
[छात्र] सीज़र छद्मकरण सिर्फ यह है कि आप नक्शे, आप हर पत्र पाली,

92
00:07:28,100 --> 00:07:34,420
पत्र की एक निश्चित संख्या से अधिक जाओ, और अधिक वापस ले जाने, और यह बहुत ही सुरक्षित नहीं है, क्योंकि

93
00:07:34,420 --> 00:07:42,260
वहाँ केवल 26 संभव विकल्प है और तुम सिर्फ उन में से 1 हर कोशिश है जब तक आप इसे पाने के लिए है.

94
00:07:42,260 --> 00:07:45,470
ओह. तो, मैं दोहराना चाहिए?

95
00:07:45,470 --> 00:07:51,600
सीज़र छद्मकरण, it's - मेरा मतलब है, आप इसके साथ आपको लगता है कि समस्याओं पर काम कर सकता हूँ -

96
00:07:51,600 --> 00:07:56,110
या मैं समस्या सेट है कि हैकर संस्करण पर नहीं है के मानक संस्करण लगता है.

97
00:07:56,110 --> 00:08:01,550
तो समस्या सेट करने के लिए मानक संस्करण पर, आप की तरह, एक संदेश मिलता है "विश्व नमस्कार,,"

98
00:08:01,550 --> 00:08:08,410
और आप भी 6 की तरह एक नंबर है, और आपको लगता है कि संदेश ले, और प्रत्येक व्यक्ति के चरित्र,

99
00:08:08,410 --> 00:08:11,310
आप यह वर्णमाला में 6 पदों से बारी बारी.

100
00:08:11,310 --> 00:08:16,560
तो 'ज' हैलो में घंटे - मैं जम्मू - कश्मीर - एल मीटर n बन जाएगा.

101
00:08:16,560 --> 00:08:19,600
तो पहले अक्षर होगा. हम ई के साथ एक ही बात करते हैं.

102
00:08:19,600 --> 00:08:23,530
यदि हम एक है, की तरह, z या कुछ और, तो हम वापस आसपास लपेट के लिए 'एक.'

103
00:08:23,530 --> 00:08:29,280
लेकिन प्रत्येक वर्ण साइकिल 6 अक्षर बाद वर्णमाला में हो जाता है, और यह बहुत ही सुरक्षित नहीं है

104
00:08:29,280 --> 00:08:35,440
के बाद से वहाँ कैसे कई मायनों आप एक पत्र लपेट सकता है के लिए केवल 26 संभावनाएं हैं.

105
00:08:35,440 --> 00:08:42,919
तो तुम सिर्फ उनमें से 26 सब करने की कोशिश कर सकते हैं और, संभवतः एक लंबे समय पर्याप्त संदेश के लिए,

106
00:08:42,919 --> 00:08:46,860
केवल उन संभव 26 बातें की 1 सुपाठ्य होना जा रहा है,

107
00:08:46,860 --> 00:08:50,300
और सुपाठ्य एक मूल संदेश को होने जा रहा है.

108
00:08:50,300 --> 00:08:56,240
तो यह सब कुछ encrypting की एक बहुत अच्छा तरीका नहीं है.

109
00:08:56,240 --> 00:08:59,070
उन शॉर्ट्स से संबंधित "क्या एक समारोह है?"

110
00:08:59,070 --> 00:09:03,370
तो एक समारोह में क्या है? हां.

111
00:09:03,370 --> 00:09:11,640
[छात्र] यह कोड का एक टुकड़ा अलग है कि आप के माध्यम से जाना और फिर कॉल कर सकते हैं जो कुछ भी मान प्राप्त की तरह है.

112
00:09:11,640 --> 00:09:18,160
हाँ. भी सिर्फ अगले एक जवाब देने के द्वारा या दोहराने - तो मैं यह भी अगले जवाब देने के द्वारा जवाब देंगे.

113
00:09:18,160 --> 00:09:22,410
आप कार्य के बजाय सिर्फ नकल और चिपकाने के कोड का उपयोग कर सकते हैं और फिर से.

114
00:09:22,410 --> 00:09:27,200
बस ले कि कोड, यह एक fuction में डाल दिया, और फिर तुम सिर्फ समारोह में कह सकते हैं

115
00:09:27,200 --> 00:09:29,870
आप जहाँ भी नकल किया गया है और चिपकाने.

116
00:09:29,870 --> 00:09:33,350
तो कार्य उपयोगी होते हैं.

117
00:09:33,350 --> 00:09:35,860
तो अब हम वास्तविक समस्याओं करूँगा.

118
00:09:35,860 --> 00:09:46,490
पहले एक. तो पहले एक विचार है, तो आप इसे एक स्ट्रिंग के पास है, और की परवाह किए बिना -

119
00:09:46,490 --> 00:09:52,060
या यह सभी लोअरकेस कहना है? यह सभी लोअरकेस नहीं कहना है.

120
00:09:52,060 --> 00:09:57,730
संदेश तो कुछ भी हो सकता है, और कर सकते हैं - अरे नहीं. यह करता है.

121
00:09:57,730 --> 00:10:01,610
सादगी के लिए, आप कि उपयोगकर्ता केवल लोअरकेस अक्षरों और स्थान के इनपुट. मान सकते हैं. "

122
00:10:01,610 --> 00:10:08,180
तो हम इसे केवल लोअरकेस अक्षरों के साथ एक संदेश देना और फिर हम वैकल्पिक

123
00:10:08,180 --> 00:10:15,450
कैपिटल और लोअरकेस के बीच - हम पूंजी और लोअरकेस स्ट्रिंग होने के लिए, बारी बदल जाते हैं.

124
00:10:15,450 --> 00:10:22,920
तो इससे पहले कि हम आपको एक भी समस्या में गोता लगाने के लिए 2 दे,

125
00:10:22,920 --> 00:10:32,420
पहली बात यह है कि हम क्या करने की जरूरत क्या है?

126
00:10:32,420 --> 00:10:36,900
ओह, मैं क्या बस पर क्लिक करें? ओह, मैं बस यहाँ एक ईमेल पर क्लिक किया.

127
00:10:36,900 --> 00:10:42,870
पहली बात तो हम क्या करने की जरूरत है - मैं एक गलत देख रहा हूँ?

128
00:10:42,870 --> 00:10:49,320
यह इस एक का हिस्सा है?

129
00:10:49,320 --> 00:10:51,320
नहीं, वे वहाँ में हालांकि अभी भी कर रहे हैं.

130
00:10:51,320 --> 00:10:55,160
ठीक है, अभी भी यहाँ.

131
00:10:55,160 --> 00:11:03,160
- अब हम कल्पना नहीं कर सकते? हां. यहाँ हम कल्पना नहीं कर सकते कि यह केवल लोअरकेस और रिक्त स्थान है.

132
00:11:03,160 --> 00:11:07,770
तो अब हम तथ्य यह है कि पत्र हो सकता है जो कुछ भी हम उन्हें होना चाहते हैं के साथ सौदा किया है.

133
00:11:07,770 --> 00:11:11,910
और तो पहली बात हम करना चाहते हैं बस संदेश मिलता है.

134
00:11:11,910 --> 00:11:19,790
हम सिर्फ एक स्ट्रिंग प्राप्त करने की जरूरत है, स्ट्रिंग एस = GetString, ठीक है.

135
00:11:19,790 --> 00:11:24,890
अब यह समस्या है, वहाँ इसे कर के तरीके के एक जोड़े हैं.

136
00:11:24,890 --> 00:11:29,840
लेकिन हम बिटवाइस ऑपरेटरों यहाँ का उपयोग करना चाहते करने के लिए जा रहे हैं.

137
00:11:29,840 --> 00:11:35,280
वहाँ जो लोग या तो supersection में नहीं थे,

138
00:11:35,280 --> 00:11:37,480
या कुछ पता है, और नहीं है बिटवाइस ऑपरेटरों क्या कर रहे हैं?

139
00:11:37,480 --> 00:11:41,710
या कि वे किसी भी तरह से संबंधित ASCII?

140
00:11:41,710 --> 00:11:45,650
[छात्र] मैं supersection में नहीं था, लेकिन मैं जानता हूँ कि बिटवाइस ऑपरेटरों क्या कर रहे हैं.

141
00:11:45,650 --> 00:11:49,560
ठीक है. तो फिर मैं उनमें से मूल पर जाना नहीं है, लेकिन मैं समझाता हूँ

142
00:11:49,560 --> 00:11:51,830
हम क्या करने के लिए यहाँ का उपयोग करना चाहते हैं के लिए जा रहे हैं.

143
00:11:51,830 --> 00:11:59,680
तो 'ए': राजधानी के एक द्विआधारी प्रतिनिधित्व, संख्या 65 है.

144
00:11:59,680 --> 00:12:07,560
मैं तो बस को देखने के लिए जा रहा हूँ - 41 01000001 होने जा रहा है.

145
00:12:07,560 --> 00:12:14,170
तो यह है कि 65 दशमलव में होना चाहिए, तो यह चरित्र राजधानी ए के द्विआधारी प्रतिनिधित्व है

146
00:12:14,170 --> 00:12:19,440
अब, चरित्र की द्विआधारी प्रतिनिधित्व 'एक' लोअरकेस

147
00:12:19,440 --> 00:12:33,350
एक ही बात हो, लगभग जा रहा है. - 6, हाँ. यह सही है.

148
00:12:33,350 --> 00:12:37,670
तो बाइनरी राजधानी एक द्विआधारी लोअरकेस 'एक.'

149
00:12:37,670 --> 00:12:43,940
तो सूचना है कि एक और 'एक' यह एक सा है. के बीच अंतर

150
00:12:43,940 --> 00:12:49,440
और यह 32 बिट, 32 बिट संख्या का प्रतिनिधित्व होता है.

151
00:12:49,440 --> 00:12:53,910
और कहा कि समझ में आता है, के बाद से एक 65 है, 'एक' 97 है.

152
00:12:53,910 --> 00:12:56,610
उन दोनों के बीच का अंतर 32 है.

153
00:12:56,610 --> 00:13:03,770
तो अब हम जानते हैं कि हम एक 'एक' से एक लेने के द्वारा परिवर्तित कर सकते हैं

154
00:13:03,770 --> 00:13:09,710
और यह बिटवाइस oring, के साथ है कि 1 एक की तरह लग रहा है.

155
00:13:09,710 --> 00:13:20,900
यह एक बिटवाइस या 00100000 के साथ है, और कहा कि हमें दे दूँगा 'एक.'

156
00:13:20,900 --> 00:13:26,850
और हम 'एक' से बिटवाइस anding द्वारा प्राप्त कर सकते हैं

157
00:13:26,850 --> 00:13:33,700
के साथ 11, कि जगह, 11111 में 0.

158
00:13:33,700 --> 00:13:43,840
तो यह तो हमें दे वास्तव में क्या 'एक' था, लेकिन बाहर इस व्यक्ति सा रद्द,

159
00:13:43,840 --> 00:13:50,070
इसलिए हम 01000001 होगा, मैं नहीं पता है कि अगर मैं सही गिना.

160
00:13:50,070 --> 00:13:56,750
लेकिन बिटवाइस oring के इस तकनीक राजधानी से प्राप्त करने के लिए लोअरकेस,

161
00:13:56,750 --> 00:14:02,080
और बिटवाइस लोअरकेस से राजधानी के लिए anding ए के लिए विशेष नहीं है

162
00:14:02,080 --> 00:14:06,510
पत्र के सभी, कश्मीर बनाम कश्मीर, Z बनाम z,

163
00:14:06,510 --> 00:14:10,080
उन सभी को सिर्फ इस एकल बिट से अलग करने के लिए जा रहे हैं.

164
00:14:10,080 --> 00:14:16,290
और इसलिए आप इस प्रयोग को किसी भी पूंजी पत्र और ठीक इसके विपरीत किसी भी लोअरकेस अक्षर से बदल सकते हैं.

165
00:14:16,290 --> 00:14:26,670
ठीक है. तो इस से होने का एक आसान तरीका है - तो बदले में होने

166
00:14:26,670 --> 00:14:32,170
बाहर लिखने 1011111 जो भी है इस संख्या का प्रतिनिधित्व करने का एक आसान तरीका है, और यह एक नहीं है

167
00:14:32,170 --> 00:14:39,710
कि मैं supersection में खत्म हो गया था, लेकिन टिल्ड (~) एक और बिटवाइस ऑपरेटर है.

168
00:14:39,710 --> 00:14:42,520
क्या करता है ~ बिट प्रतिनिधित्व में लग रहा है.

169
00:14:42,520 --> 00:14:45,630
चलो किसी भी संख्या ले.

170
00:14:45,630 --> 00:14:53,130
यह सिर्फ कुछ बाइनरी संख्या है, और क्या है ~ यह सिर्फ बिट्स के सभी flips.

171
00:14:53,130 --> 00:15:00,630
तो यह एक 1 था, अब एक 0, यह एक 0 है, अब एक 1, 010100.

172
00:15:00,630 --> 00:15:08,320
तो यह है कि सब ~ करता है. उससे छुटकारा पाना तो संख्या 32 करने के लिए होने जा रहा है -

173
00:15:08,320 --> 00:15:23,320
इसलिए 32 00100000 संख्या होने जा रहा है, और इसलिए इस के ~ होने जा रहा है

174
00:15:23,320 --> 00:15:29,980
इस यहाँ संख्या है कि मैं के साथ 'एक' anded.

175
00:15:29,980 --> 00:15:35,600
क्या हर कोई देख रहे है? यह बहुत आम है, जब आप यह पता लगाने के लिए चाहता हूँ की तरह,

176
00:15:35,600 --> 00:15:40,740
बाद में चीजें हैं जो हम को देखकर किया जा सकता है, जब हम देखने के लिए अगर चाहते हैं के लिए -

177
00:15:40,740 --> 00:15:44,710
या हम 1 के अलावा सब कुछ चाहते हैं, हर एक बिट सेट

178
00:15:44,710 --> 00:15:47,910
आप बिट है कि हम तय नहीं चाहते ~ करते हैं.

179
00:15:47,910 --> 00:15:53,090
तो हम 32 बिट सेट नहीं करना चाहती इसलिए, हम 32 के ~ करते हैं.

180
00:15:53,090 --> 00:15:57,790
ठीक है. तो हम उन सभी का उपयोग कर सकते हैं.

181
00:15:57,790 --> 00:16:03,000
सब ठीक है, तो यह ठीक है अगर आप नहीं कर रहे हैं, हम धीरे धीरे पर एक साथ चलना होगा,

182
00:16:03,000 --> 00:16:11,870
या इस पर चलना है, तो इस के माध्यम से. इस के माध्यम से चलो.

183
00:16:11,870 --> 00:16:20,790
इसलिए हम अपने स्ट्रिंग है, और हम कि स्ट्रिंग में प्रत्येक चरित्र पर पाश के लिए करना चाहते हैं और यह करने के लिए कुछ है.

184
00:16:20,790 --> 00:16:26,710
तो कैसे हम एक स्ट्रिंग पर पाश करते हैं? हम क्या इस्तेमाल करना चाहिए?

185
00:16:26,710 --> 00:16:30,980
मैं इसे यहाँ पर नहीं जा रहा हूँ. हाँ.

186
00:16:30,980 --> 00:16:42,940
इसलिए मैं अपने iterator है, और वह यह कहा है, लेकिन मैं कैसे पता है कि कितने अक्षर स्ट्रिंग में कर रहे हैं?

187
00:16:42,940 --> 00:16:47,030
Strlen (), तो मैं + +.

188
00:16:47,030 --> 00:16:49,860
तो क्या मैं यहाँ किया है बातें करने का सबसे अच्छा तरीका नहीं है.

189
00:16:49,860 --> 00:16:51,860
क्या किसी को पता है क्यों?

190
00:16:51,860 --> 00:16:55,290
क्योंकि आप हर बार स्ट्रिंग की भाषा की जाँच कर रहे हैं.

191
00:16:55,290 --> 00:17:06,859
तो हम करने के लिए strlen स्थानांतरित करना चाहते करने के लिए जा रहे हैं, मैं यहाँ कह सकता है, int लंबाई strlen = (ओं),

192
00:17:06,859 --> 00:17:11,900
और फिर मैं लंबाई <करते हैं, और इस मामले में आप पहले कभी नहीं देखा यह नहीं है,

193
00:17:11,900 --> 00:17:20,410
मैं भी कर सकता है int i = 0 लंबाई, strlen = (ओं).

194
00:17:20,410 --> 00:17:25,010
और इसलिए यह कुछ हद तक बेहतर है, अब के बाद से मैं गुंजाइश प्रतिबंधित है

195
00:17:25,010 --> 00:17:29,150
चर लंबाई के बस पाश 'के लिए' इस के बजाय, पहले यह की घोषणा

196
00:17:29,150 --> 00:17:34,990
और कहा कि यह हमेशा से मौजूद है, और इस मामले में तुम क्यों है कि बुरा है पकड़ नहीं किया था,

197
00:17:34,990 --> 00:17:39,410
मूल या बुरा, क्यों it's था - पाश के लिए शुरू.

198
00:17:39,410 --> 00:17:43,380
मैं इस हालत की जाँच की. मैं एस की लंबाई <?

199
00:17:43,380 --> 00:17:46,790
तो एस की लंबाई, के साथ "नमस्ते" पूरे समय काम.

200
00:17:46,790 --> 00:17:49,670
है तो लंबाई, ज ए एल एल ओ. लंबाई 5 है.

201
00:17:49,670 --> 00:17:57,580
तो मैं = 0 लंबाई, 5 है, तो मैं <5 नहीं है तो, पाश जारी है.

202
00:17:57,580 --> 00:18:02,750
तो हम फिर जाओ. हम स्थिति की जाँच करें. मैं हैलो की लंबाई <?

203
00:18:02,750 --> 00:18:08,390
तो चलो हैलो की लंबाई की जाँच करें. एच ए एल एल ओ. कि 5, मैं <5 नहीं है, तो हम फिर से जारी है.

204
00:18:08,390 --> 00:18:13,330
तो हम की गणना कर रहे हैं, लूप के प्रत्येक चलना के लिए हैलो हम भरोसा कर रहे हैं,

205
00:18:13,330 --> 00:18:17,380
यह भी सोचा था कि यह कभी नहीं बदल रहा है, यह हमेशा के लिए 5 से होने जा रहा है.

206
00:18:17,380 --> 00:18:22,530
तो हम सिर्फ सामने चुप 5 याद है, और अब सब कुछ बेहतर है.

207
00:18:22,530 --> 00:18:24,990
तो पूरे स्ट्रिंग पर iterating.

208
00:18:24,990 --> 00:18:31,470
हम क्या स्ट्रिंग के प्रत्येक चरित्र के लिए करना चाहते हैं?

209
00:18:31,470 --> 00:18:38,510
[छात्र बोल, दुर्बोध]

210
00:18:38,510 --> 00:18:47,000
हाँ. तो, अगर गैर वर्णमाला चरित्र है, तो हम सिर्फ यह पर छोड़ करना चाहते हैं.

211
00:18:47,000 --> 00:18:52,300
क्योंकि हम केवल वर्णमाला पत्र के बारे में परवाह है, हम एक नंबर नहीं कैपिटल कर सकते हैं.

212
00:18:52,300 --> 00:19:10,850
तो हम यह कैसे कर सकते हैं? तो हमारी हालत, इसलिए यदि हम कुछ करना चाहते हैं - अगर यह वर्णमाला है.

213
00:19:10,850 --> 00:19:14,060
तो कैसे हम इस जाँच करते हैं?

214
00:19:14,060 --> 00:19:18,720
[छात्र] अल्फा तुम सिर्फ समारोह का उपयोग कर सकते है.

215
00:19:18,720 --> 00:19:23,160
यह है कि इनमें से किसी के, या किसी भी रूप में शामिल तरह char.h, या कुछ में शामिल हैं?

216
00:19:23,160 --> 00:19:32,710
इसलिए हम [i] है, चलो अल्फा समारोह है, और स्पष्ट का उपयोग करें का उपयोग नहीं

217
00:19:32,710 --> 00:19:40,460
कि एस के 8 चरित्र है, याद है कि एक स्ट्रिंग वर्णों की एक सरणी है,

218
00:19:40,460 --> 00:19:43,180
एस के 8 चरित्र इतना.

219
00:19:43,180 --> 00:19:49,280
अब, अगर यह एक पूंजी पत्र है, हम जानते हैं कि यह एक विशिष्ट श्रेणी में हो गया है.

220
00:19:49,280 --> 00:19:54,370
और कहा कि सीमा क्या है?

221
00:19:54,370 --> 00:20:07,860
हाँ. तो अगर मैं 65 ≥, और मैं 90 ≤ है, मैं क्या बजाय करना चाहिए?

222
00:20:07,860 --> 00:20:18,470
हाँ. तो तुम कभी भी कुछ भी की ASCII मान पता बिल्कुल भी कभी नहीं की जरूरत होनी चाहिए.

223
00:20:18,470 --> 00:20:25,640
कभी लगता है कि संख्या 65, 90, 97 और 102, या जो भी यह है.

224
00:20:25,640 --> 00:20:32,470
112 - तुम नहीं की जरूरत नहीं है? आप उन सभी में जानने की जरूरत नहीं है. यह भी गलत है.

225
00:20:32,470 --> 00:20:41,940
केवल एकल बोली वर्ण, एकल उद्धरण स्थिर का उपयोग करें. तो 'ए' और कम से कम 90 'जेड'

226
00:20:41,940 --> 00:20:47,930
और यह काफी बेहतर है - मैं मेरे सिर के ऊपर से है कि जेड 90 है नहीं पता होगा.

227
00:20:47,930 --> 00:20:52,690
मैं मेरे सिर के ऊपर से पता नहीं है कि 'जेड' राजधानी जेड

228
00:20:52,690 --> 00:21:02,100
इतने लंबे समय के रूप में के रूप में इस पूंजी की राजधानी Z, या हम सीमा में है लोअरकेस के लिए जाँच कर सकते हैं,

229
00:21:02,100 --> 00:21:17,010
या अगर यह रेंज में है ≥ 'एक' और ≤ Z.

230
00:21:17,010 --> 00:21:19,010
तो यह है कि हमारी हालत है.

231
00:21:19,010 --> 00:21:22,520
जहां इन चीजों डाल करने के लिए शैली होती है.

232
00:21:22,520 --> 00:21:29,520
मैं इसे इस तरह से करना होगा.

233
00:21:29,520 --> 00:21:31,520
अब, हम क्या करना चाहते हैं?

234
00:21:31,520 --> 00:21:39,530
हम जानते हैं कि इस पत्र को एक चरित्र है, एक अक्षर.

235
00:21:39,530 --> 00:21:46,270
तो हम क्या अब यह एक पूंजी पत्र या एक लोअरकेस अक्षर होना चाहिए के बीच वैकल्पिक करने की जरूरत है.

236
00:21:46,270 --> 00:21:48,820
हम ट्रैक जिनमें से एक हम इसे होना चाहते कैसे रहते हो?

237
00:21:48,820 --> 00:21:55,520
[छात्र आवाज, unintelligible]

238
00:21:55,520 --> 00:21:59,150
हाँ तो करते हैं, लेकिन मुझे जाँच.

239
00:21:59,150 --> 00:22:04,910
0-2 मॉड्यूल कहा गया था, एक सुझाव बाहर फेंक दिया था, और मैं उस के साथ सहमत हूँ.

240
00:22:04,910 --> 00:22:11,780
नोटिस के सिवाय इसके कि, जैसे - यह मामला है? हाँ.

241
00:22:11,780 --> 00:22:18,270
यह हर दूसरे एक है, लेकिन हम नहीं कर सकते हैं मैं के 2 मॉड्यूल, या मैं 2 आधुनिक, क्योंकि

242
00:22:18,270 --> 00:22:22,950
सूचना है कि ई राजधानी है और 'एक' लोअरकेस है? लेकिन वहाँ एक जगह उन्हें अलग है?

243
00:22:22,950 --> 00:22:27,150
तो वे ही 2 आधुनिक होने के लिए जा रहे हैं, लेकिन वे अलग मामलों रहे हैं.

244
00:22:27,150 --> 00:22:29,150
[छात्र सवाल है, unintelligible]

245
00:22:29,150 --> 00:22:34,690
हाँ. तो हम सिर्फ एक गिनती रखने के लिए जा रहे हैं.

246
00:22:34,690 --> 00:22:38,730
हम यहाँ भी है कि कर सकता है अगर हम चाहते थे, कि एक छोटे से बोझल मिल सकता है

247
00:22:38,730 --> 00:22:41,300
पाश घोषणाओं के लिए, मैं इसे डाल यहाँ हूँ.

248
00:22:41,300 --> 00:22:48,840
तो int गिनती = 0 में शुरू होता है.

249
00:22:48,840 --> 00:22:54,070
और इसलिए अब, मैं गिनती कितने वर्णमाला वर्ण हम था जा रहा हूँ.

250
00:22:54,070 --> 00:22:59,550
तो हम निश्चित रूप से गिनती + + के बाद से हम एक और अक्षर पाया जा रहे हैं.

251
00:22:59,550 --> 00:23:09,130
लेकिन, तो अब आप अगर गिनती 2 आधुनिक कह रहे हैं.

252
00:23:09,130 --> 00:23:12,590
तो क्या गिनती 2 आधुनिक अगर? ओह. मैं अब के लिए == 0 करूँगा.

253
00:23:12,590 --> 00:23:21,740
हम भी खत्म हो जाना हूँ कि. तो गिनती 2 आधुनिक == 0 अगर, तो क्या?

254
00:23:21,740 --> 00:23:27,830
[जवाब छात्रों, unintelligible]

255
00:23:27,830 --> 00:23:32,750
तो हम यह अपरकेस समाप्त करने के लिए करना चाहते हैं.

256
00:23:32,750 --> 00:23:37,520
2 मामलों रहे हैं, अपरकेस और लोअरकेस 2 मामलों रहे हैं.

257
00:23:37,520 --> 00:23:40,990
तो अगर हम लोअरकेस में कर रहे हैं हम यह अपरकेस की जरूरत है.

258
00:23:40,990 --> 00:23:43,710
यदि यह अपरकेस है हम कुछ भी करने की जरूरत नहीं है.

259
00:23:43,710 --> 00:23:50,760
लेकिन, वहाँ एक तरीका है - shouldn't रूप से फ़्लिप किया -

260
00:23:50,760 --> 00:23:54,800
कि हम भी जाँच करें कि क्या यह अपरकेस या लोअरकेस करने की जरूरत नहीं है?

261
00:23:54,800 --> 00:24:02,240
हम हमेशा यकीन है कि हम हमेशा अपरकेस पर अंत में क्या कर सकते हैं?

262
00:24:02,240 --> 00:24:07,830
तो नोटिस हम लोअरकेस 'एक' के लिए क्या किया है, क्या होगा अगर हम इस एक ही सटीक बात करने के लिए एक अपरकेस?

263
00:24:07,830 --> 00:24:11,900
एक परिवर्तन अपरकेस करता है, या मूल्य परिवर्तन करता है?

264
00:24:11,900 --> 00:24:23,100
हाँ. इसलिए किसी भी पूंजी पत्र बिटवाइस ~ 32 के साथ anded है कि एक ही अपरकेस चरित्र होने जा रहा है

265
00:24:23,100 --> 00:24:29,220
है क्योंकि किसी अपरकेस चरित्र के लिए 32 बिट सेट नहीं है.

266
00:24:29,220 --> 00:24:40,920
तो अगर हम चरित्र [i], हम यह लोअरकेस या अपरकेस बनने के लिए चाहते हैं लाने के लिए चाहते हैं.

267
00:24:40,920 --> 00:24:46,890
तो अगर यह लोअरकेस था, अब यह अपरकेस, अगर यह अपरकेस था, यह अभी भी अपरकेस, और यह बात है.

268
00:24:46,890 --> 00:24:54,290
मैं supersection में यह कहा: आप 32 का उपयोग करें यदि आप चाहते हैं, कर सकते हैं, लेकिन मैं 'एक' कर पसंद करते हैं - एक,

269
00:24:54,290 --> 00:25:01,150
के बजाय सिर्फ सादा 32 है, क्योंकि यह किसी भी अन्य सा हो सकता है.

270
00:25:01,150 --> 00:25:03,610
32 बिट के बाद, यह इनमें से कोई भी हो सकता है, कर सकते हैं या हम पर्याप्त नहीं होगा

271
00:25:03,610 --> 00:25:05,840
अक्षरों के सभी का प्रतिनिधित्व है.

272
00:25:05,840 --> 00:25:09,110
तो अगर आप 32 बिट पाने के लिए करते हैं, तो यह 64 बिट हो सकता है, यह 128 बिट हो सकता है.

273
00:25:09,110 --> 00:25:13,990
उन बिट्स के किसी भी बिट है कि अपरकेस और लोअरकेस के बीच अलग हो सकता है.

274
00:25:13,990 --> 00:25:18,350
मैं जानता हूँ कि यह 32 बिट की जरूरत नहीं होनी चाहिए.

275
00:25:18,350 --> 00:25:27,130
मैं इस 'एक' का उपयोग कर सकते हैं - एक बिट पाने के लिए है कि दोनों के बीच अलग

276
00:25:27,130 --> 00:25:33,000
जादुई संख्या 32 है पर भरोसा करने की जरूरत के बिना.

277
00:25:33,000 --> 00:25:38,770
और तो अब, और गिनती अजीब था, और इसलिए मैं क्या करना चाहते हैं?

278
00:25:38,770 --> 00:25:43,920
[छात्र जवाब, unintelligible]

279
00:25:43,920 --> 00:25:45,920
[छात्र] वह क्या है?

280
00:25:45,920 --> 00:25:49,850
मैं यह 1 सेकंड में करना होगा.

281
00:25:49,850 --> 00:25:55,690
तो अब अगर मैं चाहता हूँ - मुझे यकीन है कि चरित्र अब लोअरकेस है बनाना चाहते हैं,

282
00:25:55,690 --> 00:26:04,140
और इसलिए मैं या 32 से कर सकते हैं, और 32 'अर्थ' - ए

283
00:26:04,140 --> 00:26:06,510
लेकिन पिछले एक के रूप में एक ही तर्क के द्वारा नोटिस, कि अगर

284
00:26:06,510 --> 00:26:11,670
पत्र पहले से ही था लोअरकेस, तो oring 32 से सिर्फ यह लोअरकेस रखता है.

285
00:26:11,670 --> 00:26:16,220
यह मूल चरित्र नहीं बदला है.

286
00:26:16,220 --> 00:26:19,910
लेकिन अब मैं कहा, "यदि यह लोअरकेस है, बस इसके बारे में भूल से बचने नहीं है,

287
00:26:19,910 --> 00:26:23,650
अगर यह अपरकेस है, तो इसे बदल जाते हैं. "

288
00:26:23,650 --> 00:26:26,900
यह यह करने के लिए बहुत अधिक सुविधाजनक है.

289
00:26:26,900 --> 00:26:33,190
[छात्र] लोअरकेस काम से अपरकेस घटाकर अगर यह 32 नहीं थे कि रणनीति?

290
00:26:33,190 --> 00:26:35,330
अगर यह था, जैसे, 34 या कुछ और?

291
00:26:35,330 --> 00:26:41,840
तो, आप को पता है कि 2 के बीच का अंतर है की जरूरत है? >> 1 बिट.

292
00:26:41,840 --> 00:26:49,840
यह 1 से अधिक सा हो सकता है, के रूप में लंबे समय के रूप में इस स्थिति से नीचे बिट्स के सब एक ही हैं.

293
00:26:49,840 --> 00:26:58,500
तो हम कम से कम 26 अक्षरों की जरूरत है - या, वहाँ 26 अक्षर हैं.

294
00:26:58,500 --> 00:27:04,590
तो हम कम से कम 26 नंबर की जरूरत के लिए अंतर का प्रतिनिधित्व

295
00:27:04,590 --> 00:27:07,650
एक और 'एक' के लिए कम से कम 26 हो गया है, के बीच का अंतर

296
00:27:07,650 --> 00:27:10,760
वरना हम सभी राजधानी संख्या नहीं प्रतिनिधित्व होगा.

297
00:27:10,760 --> 00:27:18,630
इसका मतलब है कि एक, अगर हम 1 पर शुरू, यह इन बिट्स के सभी का उपयोग करने जा रहा है,

298
00:27:18,630 --> 00:27:23,900
इन 1 5 बिट्स, जेड के माध्यम से सब कुछ का प्रतिनिधित्व करने के सभी

299
00:27:23,900 --> 00:27:32,170
यह अगले क्यों बिट, या इस बिट है, अगले कुछ एक है कि करने के लिए एक और के बीच अंतर करने के लिए चुना है 'एक.'

300
00:27:32,170 --> 00:27:40,930
यही कारण है कि भी है, ASCII तालिका में, वहाँ 5 लोअरकेस अक्षरों से पूंजी पत्रों को अलग प्रतीक हैं.

301
00:27:40,930 --> 00:27:49,050
चूंकि उन प्रतीकों, अतिरिक्त 5 कि लाता है 32 उन दोनों के बीच अंतर किया जा रहा हैं.

302
00:27:49,050 --> 00:27:51,840
[छात्र] तो हम इसे करते हैं, क्योंकि ASCII के लिए डिज़ाइन किया गया है कि जिस तरह से हो सकता है.

303
00:27:51,840 --> 00:27:57,280
हां. लेकिन अंतर ASCII - भी इन बिट्स के दोनों हो सकता है.

304
00:27:57,280 --> 00:28:12,040
की तरह, अगर एक 10000001 थे, और 'एक' 11100001 था - मैं भूल जाते हैं, जो भी हो.

305
00:28:12,040 --> 00:28:18,100
ए - लेकिन अगर यह इस थे, तो हम 'एक' अभी भी इस्तेमाल कर सकते हैं

306
00:28:18,100 --> 00:28:22,650
अब यह सिर्फ एक और 'एक' अभी भी इन 2 बिट्स के बीच अंतर है.

307
00:28:22,650 --> 00:28:32,240
मुझे लगता है कि यह 48 लिखा है. यह है 32 + 64? मुझे लगता है कि यह क्या है?

308
00:28:32,240 --> 00:28:40,160
हर एक चरित्र की तरह, जेड और z कश्मीर और कश्मीर, यह अभी भी 2 बिट्स होगा

309
00:28:40,160 --> 00:28:45,160
वे अभी भी एक ही सटीक उन 2 बिट्स के लिए छोड़कर बिट सेट करना होगा.

310
00:28:45,160 --> 00:28:48,870
इतने लंबे समय के रूप में के रूप में है कि हमेशा सच है, की परवाह किए बिना अगर हम ASCII या कुछ अन्य प्रणाली का उपयोग कर रहे हैं,

311
00:28:48,870 --> 00:28:53,050
के रूप में लंबे समय के रूप में वहाँ केवल बिट्स कि प्रत्येक वर्ण के लिए अलग अलग हैं की एक निर्धारित संख्या है,

312
00:28:53,050 --> 00:28:55,050
तो यह है कि ठीक काम करता है.

313
00:28:55,050 --> 00:29:06,110
यह सिर्फ है कि 32 के लिए स्थापित किया गया था क्योंकि यह हम संभवतः इस्तेमाल कर सकते हैं 1 एक है. कूल. >>

314
00:29:06,110 --> 00:29:14,520
मैं पसंद करते हैं, के मामले में तुम्हें देखा है, नहीं तो ब्लॉक केवल एक ही लाइन है करते हैं,

315
00:29:14,520 --> 00:29:24,280
आप घुंघराले ब्रेसिज़ से छुटकारा मिल सकता है, तो मैं यह कर पसंद करते हैं.

316
00:29:24,280 --> 00:29:34,010
इसके अलावा, आप जानते हैं कि कैसे हम [i] + = 1 की तरह बातें कर सकते हैं?

317
00:29:34,010 --> 00:29:41,090
तुम भी कर सकते हैं [i] बिटवाइस और = 32.

318
00:29:41,090 --> 00:29:46,400
और बिटवाइस = 32.

319
00:29:46,400 --> 00:29:51,490
इसके अलावा, 2 आधुनिक == 0 गिनती.

320
00:29:51,490 --> 00:30:00,900
तो याद है कि मैं यह लिख नहीं होगा - किसी भी गैर शून्य मान सच है, और 0 झूठी है.

321
00:30:00,900 --> 00:30:07,880
तो "अगर गिनती 2 आधुनिक == 0" कह के रूप में एक ही है, "अगर आधुनिक 2 गिनती नहीं है."

322
00:30:07,880 --> 00:30:11,580
शायद मैं लाइनें है उलट होता है और कहा, "अगर गिनती आधुनिक 2,

323
00:30:11,580 --> 00:30:15,350
करते हैं या 1, और 1 है, "इतना है कि मैं की जरूरत है नहीं किया था." नहीं "

324
00:30:15,350 --> 00:30:18,650
लेकिन यह बस के रूप में अच्छी तरह से काम करता है.

325
00:30:18,650 --> 00:30:25,660
और क्या मैं यहाँ क्या कर सकते हैं?

326
00:30:25,660 --> 00:30:29,060
आप उन्हें त्रिगुट के साथ गठबंधन अगर तुम चाहते थे, सकता है, लेकिन तब है कि सिर्फ बातें messier बनाना चाहते हैं

327
00:30:29,060 --> 00:30:33,770
और शायद अधिक पढ़ने के लिए मुश्किल है, इसलिए हम नहीं है कि क्या करेंगे.

328
00:30:33,770 --> 00:30:37,330
किसी को भी किसी भी अन्य सुझाव है?

329
00:30:37,330 --> 00:30:41,580
कि सभी समस्या के लिए कहा है? ओह, हाँ.

330
00:30:41,580 --> 00:30:51,070
तो इन खाली लाइनों से छुटकारा पाने के लिए, अब हम च% मुद्रित करेंगे तार के लिए एक किया जा रहा है,

331
00:30:51,070 --> 00:30:56,620
हम च प्रिंट, एस.

332
00:30:56,620 --> 00:30:59,330
अब चलो इसे चलाने के लिए. क्या मैंने कुछ गलत किया?

333
00:30:59,330 --> 00:31:03,200
यह एक \ "; मैं एक n चाहते.

334
00:31:03,200 --> 00:31:07,840
ठीक है. अब हम यह भाग लेंगे. यह शायद मुझ पर चिल्लाना होगा.

335
00:31:07,840 --> 00:31:11,250
Strlen string.h में है.

336
00:31:11,250 --> 00:31:14,290
तो इस है बजना के बारे में अच्छी बात यह है यह आपको बताता है कि यह क्या है,

337
00:31:14,290 --> 00:31:19,140
बजाय जीसीसी जो सिर्फ कहते हैं, "अरे, तुम कुछ भूल गया, मैं नहीं जानता कि यह क्या था नहीं है."

338
00:31:19,140 --> 00:31:29,220
, लेकिन यह मुझे बताओ, "तुम string.h शामिल करने का मतलब है."

339
00:31:29,220 --> 00:31:32,130
तो मैं कुछ भी करने के लिए प्रांप्ट नहीं था, तो यह कुछ भी नहीं कह रहा है.

340
00:31:32,130 --> 00:31:42,540
लेकिन, "4 जोड़ धन्यवाद" हम उनके उदाहरण करूँगा.

341
00:31:42,540 --> 00:31:47,880
यह सही लग रहा है. हुर्रे.

342
00:31:47,880 --> 00:31:52,370
तो अपने मुख्य लौटने, मैं लगभग यह कभी नहीं.

343
00:31:52,370 --> 00:31:57,110
यह वैकल्पिक है. और मुख्य केवल समारोह जिसके लिए यह वैकल्पिक है.

344
00:31:57,110 --> 00:32:07,140
यदि आप कुछ मुख्य से वापस नहीं करते हैं, तो यह मान लिया है कि आप 0 वापसी का मतलब है.

345
00:32:07,140 --> 00:32:13,070
प्रश्न?

346
00:32:13,070 --> 00:32:20,980
ठीक है. तो अब दूसरी समस्या.

347
00:32:20,980 --> 00:32:24,810
"पासिंग द्वारा सप्ताह 2 2 व्याख्यान कि 2 चर मूल्यों गमागमन से याद

348
00:32:24,810 --> 00:32:30,780
एक समारोह के लिए (भी अगर स्वैप बुलाया) उन 2 चर बिल्कुल बिना कम से कम नहीं, काम नहीं 'संकेत' करता है "

349
00:32:30,780 --> 00:32:37,020
और संकेत की अनदेखी जब तक हम उन्हें पाने के लिए.

350
00:32:37,020 --> 00:32:40,070
हम 2 चर स्वैप करना चाहते हैं, हम एक समारोह का उपयोग करने के लिए यह कर रहे हैं.

351
00:32:40,070 --> 00:32:43,410
हम अभी भी यह मुख्य में क्या करना पसंद इसे कहते हैं, के लिए जा रहे हैं.

352
00:32:43,410 --> 00:32:48,360
लेकिन उन 2 चर का उपयोग करने के लिए, हम करने के लिए एक अस्थायी चर का उपयोग नहीं करना चाहती.

353
00:32:48,360 --> 00:32:50,770
वहाँ दो तरीके से ऐसा कर रहे हैं.

354
00:32:50,770 --> 00:32:56,310
आप इसे अपने पारंपरिक द्विआधारी ऑपरेटरों का उपयोग कर सकते हैं.

355
00:32:56,310 --> 00:33:00,180
तो किसी को भी है कि कर का एक त्वरित और गंदे तरीका पता है?

356
00:33:00,180 --> 00:33:07,650
यह वास्तव में सोच का एक मिनट लग सकता है. यदि मेरे पास है -

357
00:33:07,650 --> 00:33:12,130
मैं इस समस्या के सेट अप की तरह वे पूछता हूँ. तो अगर मैं 2 चर है, एक है, जो सिर्फ एक पूर्णांक है

358
00:33:12,130 --> 00:33:17,800
कि वे मुझे दे, और राशि चर बी है, जो एक और पूर्णांक है कि मैं दिया हूँ.

359
00:33:17,800 --> 00:33:22,700
तो अगर मैं इन 2 चर है, अब मैं उन्हें स्वैप के लिए करना चाहते हैं.

360
00:33:22,700 --> 00:33:31,550
पारंपरिक, अपने नियमित रूप से बाइनरी ऑपरेटर्स का उपयोग कर, मेरा मतलब है, + तरह, ÷.

361
00:33:31,550 --> 00:33:36,630
नहीं बिटवाइस ऑपरेटरों जो बाइनरी पर काम करते हैं.

362
00:33:36,630 --> 00:33:39,600
तो, + ÷, सभी और उन का उपयोग कर.

363
00:33:39,600 --> 00:33:52,980
हम जैसे कुछ करके स्वैप सकता है एक = एक + ख, और ख = एक - ख, एक = एक - ख.

364
00:33:52,980 --> 00:34:04,260
तो, विवेक की जाँच करें, और फिर हम यही वजह है कि काम देखेंगे.

365
00:34:04,260 --> 00:34:13,320
चलो का कहना है कि एक = 7, b = 3, तो एक + ख से 10 होने जा रहा है.

366
00:34:13,320 --> 00:34:18,820
तो हम अब एक = 10 की स्थापना कर रहे हैं, और फिर हम ख = एक कर रहे हैं - ख.

367
00:34:18,820 --> 00:34:30,250
तो हम क्या कर रहे हैं ख = एक - ख, जो 7 होने जा रहा है, और ख = एक - ख फिर,

368
00:34:30,250 --> 00:34:38,650
या एक = एक - ख. 7 जो 3 - कौन से 10 होने जा रहा है.

369
00:34:38,650 --> 00:34:44,850
तो अब, सही ढंग से 'एक', 7 था, ख 3 था, और अब ख 7 है और 'एक 3' है.

370
00:34:44,850 --> 00:34:48,679
तो उस तरह की समझ में आता है, 'एक' 2 नंबर के संयोजन है.

371
00:34:48,679 --> 00:34:53,000
इस बिंदु पर, 'एक' संयोजन है, और फिर हम बाहर मूल ख subtracting कर रहे हैं,

372
00:34:53,000 --> 00:34:56,860
और फिर हम बाहर घटाकर क्या कर रहे हैं मूल था 'एक.'

373
00:34:56,860 --> 00:35:01,150
लेकिन यह सभी नंबरों के लिए काम नहीं करता.

374
00:35:01,150 --> 00:35:08,880
यह देखने के लिए है, चलो एक प्रणाली पर विचार करें, तो हम आम तौर पर लगता है कि 32 बिट के रूप में integers के.

375
00:35:08,880 --> 00:35:13,050
चलो कुछ है कि केवल 4 बिट्स की तरह है पर काम.

376
00:35:13,050 --> 00:35:15,450
उम्मीद है कि मैं एक अच्छा उदाहरण के साथ अभी आते हैं.

377
00:35:15,450 --> 00:35:18,680
तो मुझे पता है, यह आसान हो जाएगा.

378
00:35:18,680 --> 00:35:26,720
चलो का कहना है कि हमारे 2 नंबर 1111, 1111 और कर रहे हैं, तो हम बाइनरी में सही अब कर रहे हैं.

379
00:35:26,720 --> 00:35:34,630
वास्तविक दशमलव में, यदि आप इसे की तरह लगता है चाहता हूँ, एक = 15 और b = 15.

380
00:35:34,630 --> 00:35:37,630
और इसलिए हम उम्मीद करते हैं, के बाद हम उन्हें स्वैप - वे भी एक ही नंबर नहीं है,

381
00:35:37,630 --> 00:35:41,140
लेकिन मैं इसे इस तरह से किया.

382
00:35:41,140 --> 00:35:47,100
चलो उन्हें एक ही नंबर बनाने के लिए नहीं. है 1111 और 0001.

383
00:35:47,100 --> 00:35:51,860
तो एक = 15 और ख = 1.

384
00:35:51,860 --> 00:35:57,670
के बाद हम उन्हें स्वैप, हम 'एक' के लिए एक और ख 15 होने की उम्मीद है.

385
00:35:57,670 --> 00:36:01,780
तो हमारा पहला कदम है एक = एक + ख.

386
00:36:01,780 --> 00:36:08,770
हमारी संख्या केवल 4 बिट्स व्यापक हैं, तो 'एक', जो 1111 है + ख है, जो 0001 है,

387
00:36:08,770 --> 00:36:16,780
अंत 10000 जा रहा है जा रहा है, लेकिन हम केवल 4 बिट्स है.

388
00:36:16,780 --> 00:36:22,540
तो अब एक = 0.

389
00:36:22,540 --> 00:36:34,080
ख - वास्तव में, यह अभी भी पूरी तरह से बाहर काम करता है और अब हम करने के लिए सेट ख = एक के लिए करना चाहते हैं.

390
00:36:34,080 --> 00:36:39,630
एक = एक - ख - चलो देखते हैं अगर यह पूरी तरह से काम करता है.

391
00:36:39,630 --> 00:36:53,720
तो फिर ख = 0 - 1,, जो अभी भी 15 होगा और फिर एक = एक - ख है, जो 1 होगा.

392
00:36:53,720 --> 00:36:56,210
हो सकता है कि यह काम करता है.

393
00:36:56,210 --> 00:36:59,020
मुझे लगता है कि वहाँ एक कारण है कि यह नियमित रूप से का उपयोग कर काम नहीं करता है.

394
00:36:59,020 --> 00:37:06,400
ठीक है, तो धारणा है कि यह नियमित रूप से बाइनरी आपरेशनों के साथ काम नहीं करता है पर काम कर रहा है,

395
00:37:06,400 --> 00:37:15,040
और मैं के लिए दिखेगा - मैं देखना है कि अगर सच है गूगल.

396
00:37:15,040 --> 00:37:23,490
तो हम ऐसा करने के लिए bitwise ऑपरेटरों का उपयोग करना चाहते हैं, और यहाँ सुराग XOR है.

397
00:37:23,490 --> 00:37:28,780
तो, XOR (^) शुरू अगर आप अभी तक नहीं देखा है.

398
00:37:28,780 --> 00:37:34,610
ऐसा नहीं है, फिर से, एक bitwise ऑपरेटर तो यह सा है, और it's द्वारा सा काम करता है -

399
00:37:34,610 --> 00:37:39,910
यदि आप 0 और 1 बिट्स है, तो यह 1 होगा.

400
00:37:39,910 --> 00:37:45,230
यदि आप बिट्स 1 और 0 है, यह 1 होगा, आप बिट्स 0 और 0 0 हो जाएगा है,

401
00:37:45,230 --> 00:37:47,640
और अगर आप बिट्स 1 और 1 यह 0 हो जाएगा.

402
00:37:47,640 --> 00:37:56,180
तो यह की तरह है या. यदि बिट्स की या तो सच हैं, यह एक है, लेकिन या विपरीत, यह दोनों बिट्स कि सच नहीं हो सकता है.

403
00:37:56,180 --> 00:37:59,320
या यह होगा 1, XOR इस 0 हो.

404
00:37:59,320 --> 00:38:02,250
तो हम करने के लिए XOR यहाँ का उपयोग करना चाहते हैं के लिए जा रहे हैं.

405
00:38:02,250 --> 00:38:09,960
एक मिनट के लिए इसके बारे में सोचो, मैं गूगल के लिए जा रहा हूँ.

406
00:38:09,960 --> 00:38:16,230
खैर, आपको लगता है कि नहीं पढ़ सकते हैं, मैं XOR की स्वैप एल्गोरिथ्म पृष्ठ पर वर्तमान में हूँ.

407
00:38:16,230 --> 00:38:21,340
उम्मीद है कि यह समझा जाएगा क्यों मैं can't -

408
00:38:21,340 --> 00:38:34,190
यह वास्तव में एल्गोरिथ्म है कि हम सिर्फ किया है.

409
00:38:34,190 --> 00:38:37,330
मैं अभी भी क्यों नहीं दिख रहा है - मैं बस एक बुरा उदाहरण उठाया जाना चाहिए,

410
00:38:37,330 --> 00:38:44,940
लेकिन इस मामले में जहां 'एक' 0 हो, 5 बिट्स के लिए मिलने के बाद, तो अब 'एक' 0 है हुआ

411
00:38:44,940 --> 00:38:48,730
वह यह है कि क्या कहा जाता है "पूर्णांक अतिप्रवाह."

412
00:38:48,730 --> 00:38:54,370
विकिपीडिया के अनुसार, "XOR स्वैप के विपरीत, इस भिन्नता की आवश्यकता है कि यह कुछ तरीकों का उपयोग करता है

413
00:38:54,370 --> 00:38:59,780
गारंटी है कि x + y एक पूर्णांक अतिप्रवाह कारण नहीं है. "

414
00:38:59,780 --> 00:39:08,350
तो यह समस्या है; इस पूर्णांक अतिप्रवाह थी, लेकिन मैंने कुछ गलत किया है.

415
00:39:08,350 --> 00:39:10,520
मैं ठीक से नहीं कह सकता. मैं करने के लिए एक दूसरे के साथ आने की कोशिश करेंगे.

416
00:39:10,520 --> 00:39:13,640
[छात्र] खैर, पूर्णांक अतिप्रवाह जब तुम वहाँ में एक नंबर डालने की कोशिश कर रहे हैं नहीं है

417
00:39:13,640 --> 00:39:16,640
बिट्स की राशि आवंटित की है की तुलना में बड़ा है?

418
00:39:16,640 --> 00:39:23,730
हाँ. हम 4 बिट्स है. That's - हम 4 बिट था, हम तो यह करने के लिए 1 जोड़ने की कोशिश, तो हम 5 बिट्स के साथ खत्म होता है.

419
00:39:23,730 --> 00:39:26,690
लेकिन 5 बिट बस काट जाता है, हाँ.

420
00:39:26,690 --> 00:39:28,970
यह वास्तव में हो सकता है -

421
00:39:28,970 --> 00:39:33,010
छात्र [] कि आप एक त्रुटि फेंक, या कि करता है कि एक त्रुटि फेंक होगा?

422
00:39:33,010 --> 00:39:40,720
नहीं तो कोई त्रुटि है. जब आप विधानसभा स्तर मिलता है, एक विशेष सा

423
00:39:40,720 --> 00:39:47,020
कहीं सेट कर दिया जाता है कि ने कहा कि वहाँ एक अतिप्रवाह था, लेकिन सी में आप की तरह बस के साथ सौदा नहीं करते.

424
00:39:47,020 --> 00:39:55,160
आप वास्तव में इसके साथ सौदा नहीं है जब तक आप सी. में विशेष विधानसभा निर्देश का उपयोग कर सकते हैं

425
00:39:55,160 --> 00:39:58,110
चलो XOR स्वैप के बारे में सोचते हैं.

426
00:39:58,110 --> 00:40:02,220
और मुझे लगता है कि विकिपीडिया लेख भी हो सकता है कह दिया गया है कि -

427
00:40:02,220 --> 00:40:07,310
तो यह भी मॉड्यूलर अंकगणितीय लाया है, इसलिए मुझे लगता है मैं था, सिद्धांत रूप में, मॉड्यूलर गणित कर रहा

428
00:40:07,310 --> 00:40:11,160
जब मैंने कहा कि 0 - 1 15 फिर से है.

429
00:40:11,160 --> 00:40:15,410
तो यह है कि वास्तव में हो सकता है - 1 = 15 - एक नियमित प्रोसेसर है कि 0 करता है.

430
00:40:15,410 --> 00:40:20,430
चूंकि हम 0 पर खत्म होता है, हम 1 घटाना है, तो फिर यह सिर्फ चारों ओर 1111 के लिए वापस wraps.

431
00:40:20,430 --> 00:40:28,930
तो इस एल्गोरिथ्म वास्तव में काम करते हैं, एक + ख, एक हो सकता है - बी, बी - एक, कि ठीक हो सकता है.

432
00:40:28,930 --> 00:40:34,030
लेकिन वहाँ कुछ प्रोसेसर है जो ऐसा नहीं करते है, और इसलिए यह उन विशिष्ट लोगों में ठीक नहीं होगा.

433
00:40:34,030 --> 00:40:39,880
XOR स्वैप किसी भी प्रोसेसर पर काम करेंगे. ठीक है.

434
00:40:39,880 --> 00:40:42,280
विचार यह है कि यह एक ही हो सकता है, हालांकि माना जाता है.

435
00:40:42,280 --> 00:40:50,120
हम कहाँ XOR का उपयोग कर रहे हैं के लिए किसी भी तरह से 1 चर में दोनों की जानकारी प्राप्त करने के लिए,

436
00:40:50,120 --> 00:40:54,120
और फिर बाहर व्यक्तिगत चर की जानकारी फिर से खींचने.

437
00:40:54,120 --> 00:41:04,330
तो किसी के विचारों / जवाब है?

438
00:41:04,330 --> 00:41:14,540
[छात्र जवाब, unintelligible]

439
00:41:14,540 --> 00:41:22,220
तो यह काम करते हैं, और यह भी, XOR विनिमेय है चाहिए.

440
00:41:22,220 --> 00:41:27,620
चाहे जो क्रम के इन 2 संख्या यहाँ में होना होता है,

441
00:41:27,620 --> 00:41:30,100
इस परिणाम के लिए एक ही होने जा रहा है.

442
00:41:30,100 --> 00:41:35,800
तो एक ^ b ख ^ एक.

443
00:41:35,800 --> 00:41:51,860
आप यह भी देख सकते हैं इस के रूप में लिखा है एक ^ = ख, ख ^ = एक, एक ^ = फिर b.

444
00:41:51,860 --> 00:42:00,200
तो यह सही है, और देखने के लिए क्यों यह काम करता है, बिट्स के बारे में सोचना है.

445
00:42:00,200 --> 00:42:10,400
एक smallish नंबर का उपयोग, 11001, और 01100 का कहना है.

446
00:42:10,400 --> 00:42:12,790
तो यह 'एक' है, इस ख है.

447
00:42:12,790 --> 00:42:15,540
तो एक ^ = b.

448
00:42:15,540 --> 00:42:22,380
हम स्थापित करने के लिए इन 2 बातें XOR 'एक' = हो जा रहे हैं.

449
00:42:22,380 --> 00:42:32,920
^ 0 1 1 तो है, एक ^ 1 0 है, ^ 0 1 1 है, और ^ 0 0 0 है, एक ^ 0 1 है.

450
00:42:32,920 --> 00:42:37,380
तो ',' अगर आप दशमलव संख्या को देखो, यह करने के लिए जा रहा है -

451
00:42:37,380 --> 00:42:41,160
मूल 'एक' और नए के बीच एक संबंध की बहुत देखने जा रहा है एक 'कर रहे हैं

452
00:42:41,160 --> 00:42:45,600
लेकिन बिट्स में देख 'एक', जानकारी का एक जाल की तरह अब

453
00:42:45,600 --> 00:42:49,970
दोनों मूल 'एक' और मूल ख.

454
00:42:49,970 --> 00:42:57,930
तो अगर हम ख ^ एक, हम देखते हैं कि हम मूल में समाप्त होगा 'एक.' ले

455
00:42:57,930 --> 00:43:08,910
और अगर हम ले मूल 'एक' ^ नए 'एक,' हम देखते हैं कि हम मूल ख पर खत्म होता है.

456
00:43:08,910 --> 00:43:18,380
तो (एक ^ ख) ^ b = मूल 'एक.'

457
00:43:18,380 --> 00:43:27,910
और (एक ^ b) ^ एक = मूल ख.

458
00:43:27,910 --> 00:43:37,010
वहाँ है - देखकर यह कुछ भी XOR ही है एक और तरीका है हमेशा 0.

459
00:43:37,010 --> 00:43:45,020
^ 1101 1101 तो, सभी बिट्स के लिए एक ही होने जा रहे हैं.

460
00:43:45,020 --> 00:43:47,920
तो वहाँ एक मामले में जहां 1 एक 0 और अन्य 1 नहीं होने जा रहा है.

461
00:43:47,920 --> 00:43:51,080
तो यह 0000 है.

462
00:43:51,080 --> 00:43:57,240
इस के साथ ही. (एक ^ ख) ^ b तरह है ^ (ख ^ ख).

463
00:43:57,240 --> 00:44:03,680
(ख ख ^) 0 होने जा रहा है, एक ^ 0 बस 'होने के लिए एक,' जा रहा है के बाद से सभी बिट्स 0.

464
00:44:03,680 --> 00:44:08,050
इतना ही है कि लोगों को होने जा रहे हैं जहां 'एक' मूल रूप से किया गया था 1 एक - वाले थे.

465
00:44:08,050 --> 00:44:12,070
और यहाँ एक ही विचार है, मुझे पूरा यकीन है कि यह भी है विनिमेय हूँ.

466
00:44:12,070 --> 00:44:17,590
हाँ. मैंने कहा था कि इससे पहले कि यह विनिमेय था.

467
00:44:17,590 --> 00:44:24,680
^ ',' और यह साहचर्य है, तो अब (ख ^ एक) ^ एक.

468
00:44:24,680 --> 00:44:28,970
और हम ख ^ (एक ^ एक) कर सकते हैं.

469
00:44:28,970 --> 00:44:31,540
तो फिर, हम मूल ख मिलता है.

470
00:44:31,540 --> 00:44:37,120
तो 'एक' अब 'एक' ख और के साथ संयोजन है.

471
00:44:37,120 --> 00:44:49,660
हमारे नए combo का उपयोग 'एक' हम कहते हैं ख = कॉम्बो 'एक' ^ मूल ख, हम मूल 'एक.'

472
00:44:49,660 --> 00:45:05,170
और अब एक = कॉम्बो 'एक' ^ नई ख है, जो मूल था - या जो अब है क्या 'एक' या ख था.

473
00:45:05,170 --> 00:45:13,620
कि इस मामले यहाँ नीचे. यह = ख, ख पुरानी है.

474
00:45:13,620 --> 00:45:16,550
तो अब सब कुछ वापस बदली क्रम में है.

475
00:45:16,550 --> 00:45:22,960
यदि हम वास्तव में बिट्स में देखा, ख = एक ^ b, इन 2 XOR जा रहा है,

476
00:45:22,960 --> 00:45:33,920
और जवाब देने के लिए यह हो जा रहा है, और फिर एक = एक ^ b इन 2 XORing है और इस सवाल का जवाब यह है.

477
00:45:33,920 --> 00:45:41,090
प्रश्न? ठीक है. तो कुछ हद तक पिछले एक काफी अधिक मुश्किल है.

478
00:45:41,090 --> 00:45:43,180
[छात्र] मुझे लगता है कि वह इसके बारे में एक सवाल है. >> ओह, माफ करना.

479
00:45:43,180 --> 00:45:49,380
[छात्र] क्या वास्तव में तेजी से? यदि आप इस XOR का उपयोग करते हैं, या यह है कि अगर आप एक नया चर घोषित?

480
00:45:49,380 --> 00:45:55,190
तो क्या वास्तव में तेजी है, एक नया चर की घोषणा या XOR का उपयोग करने के लिए स्वैप?

481
00:45:55,190 --> 00:45:59,600
जवाब सभी संभावना में है, एक अस्थायी चर.

482
00:45:59,600 --> 00:46:05,780
और वह यह है कि क्योंकि यह एक बार नीचे संकलित है तो विधानसभा स्तर पर,

483
00:46:05,780 --> 00:46:12,320
वहाँ कोई स्थानीय चर या किसी भी अस्थायी चर या इस सामान की किसी भी रूप में ऐसी बात नहीं है.

484
00:46:12,320 --> 00:46:16,060
वे बस की तरह कर रहे हैं - वहाँ स्मृति है, और वहाँ रजिस्टरों हैं.

485
00:46:16,060 --> 00:46:20,920
रजिस्टरों हैं जहां चीजें सक्रिय हो रहे हैं.

486
00:46:20,920 --> 00:46:24,750
आप स्मृति में 2 बातें जोड़ नहीं है, आप रजिस्टरों में 2 बातें जोड़ने.

487
00:46:24,750 --> 00:46:28,160
और तुम रजिस्टरों में स्मृति से चीजों को लाने के लिए फिर उन्हें जोड़,

488
00:46:28,160 --> 00:46:33,180
और तब आप उन्हें वापस रख स्मृति में हो सकता है, लेकिन सभी कार्रवाई रजिस्टर में होता है.

489
00:46:33,180 --> 00:46:38,750
तो जब आप अस्थायी चर दृष्टिकोण का उपयोग कर रहे हैं, आम तौर पर क्या होता है

490
00:46:38,750 --> 00:46:42,810
इन 2 संख्या रजिस्टर में पहले से ही कर रहे हैं.

491
00:46:42,810 --> 00:46:46,570
और फिर पर, के बाद आप उन्हें बदली है कि बिंदु से,

492
00:46:46,570 --> 00:46:51,540
यह सिर्फ अन्य रजिस्टर का उपयोग शुरू करेंगे.

493
00:46:51,540 --> 00:46:56,510
कहीं तुम ख उपयोग किया गया था, यह सिर्फ रजिस्टर है कि पहले से ही भंडारण किया गया था इस्तेमाल करेंगे 'एक.'

494
00:46:56,510 --> 00:47:02,180
तो यह स्वैप करने के लिए वास्तव में क्या करने के लिए कुछ भी करने की जरूरत नहीं है. हाँ?

495
00:47:02,180 --> 00:47:05,690
[छात्र] लेकिन यह भी अधिक स्मृति लेता है, है ना?

496
00:47:05,690 --> 00:47:10,280
अगर यह है कि अस्थायी चर की दुकान की जरूरत है यह केवल अधिक स्मृति ले जाएगा.

497
00:47:10,280 --> 00:47:14,830
जैसे कि अगर आप बाद में है कि अस्थायी चर का उपयोग फिर से कहीं,

498
00:47:14,830 --> 00:47:18,920
तो या आप कुछ है कि अस्थायी चर आवंटित.

499
00:47:18,920 --> 00:47:24,630
तो अगर समय ',' अस्थायी ख में में किसी भी बिंदु पर विशिष्ट मान या कुछ और है,

500
00:47:24,630 --> 00:47:30,680
तो यह स्मृति में अलग स्थानों के लिए जा रहा है, लेकिन यह सच है कि

501
00:47:30,680 --> 00:47:34,800
वहाँ कई स्थानीय चर है जो केवल रजिस्टरों में मौजूद हैं.

502
00:47:34,800 --> 00:47:44,370
जो मामले में, यह स्मृति में डाल कभी नहीं है, और इसलिए आप स्मृति कभी नहीं बर्बाद कर रहे हैं.

503
00:47:44,370 --> 00:47:58,620
ठीक है. आखिरी सवाल थोड़ा और अधिक है.

504
00:47:58,620 --> 00:48:04,850
तो, यहाँ इस उपकरण में CS50, वहाँ एक शब्दकोश है.

505
00:48:04,850 --> 00:48:12,390
और इस के लिए कारण है क्योंकि [? B66] एक जादू चेकर जहाँ आप लिख सकता हूँ

506
00:48:12,390 --> 00:48:15,780
हैश तालिका या की कोशिश करता है या कुछ डेटा संरचना का उपयोग कर.

507
00:48:15,780 --> 00:48:22,660
आप एक जादू चेकर लिखने जा रहे हैं, और आप इस शब्दकोश का उपयोग किया वही करने जा रहे हैं.

508
00:48:22,660 --> 00:48:28,280
लेकिन इस समस्या के लिए, हम सिर्फ देखने के लिए देखने के लिए अगर एक शब्द शब्दकोश में है जा रहे हैं.

509
00:48:28,280 --> 00:48:31,250
तो कुछ डेटा संरचना में पूरे शब्दकोश भंडारण के बजाय

510
00:48:31,250 --> 00:48:35,180
और फिर एक पूरे दस्तावेज़ पर देख देखने के लिए अगर कुछ भी गलत वर्तनी है,

511
00:48:35,180 --> 00:48:38,490
हम सिर्फ एक शब्द खोजने के लिए करना चाहते हैं. तो हम बस पर पूरे शब्दकोश स्कैन कर सकते हैं

512
00:48:38,490 --> 00:48:44,300
और अगर हम पूरे शब्दकोश में शब्द खोजने के लिए कभी नहीं, तो यह वहाँ में नहीं था.

513
00:48:44,300 --> 00:48:52,150
यदि हम पूरे शब्दकोश पर स्कैन और शब्द नहीं देखते हैं, तो हम अच्छा कर रहे हैं, हम यह पाया.

514
00:48:52,150 --> 00:48:56,580
यह यहाँ का कहना है कि हम सी समारोह फ़ाइल से निपटने में तलाश शुरू करना चाहते हैं,

515
00:48:56,580 --> 00:48:59,930
क्योंकि हम शब्दकोश पढ़ना चाहते हैं,

516
00:48:59,930 --> 00:49:07,680
लेकिन मैं के रूप में कार्य करता है आप के बारे में सोचना चाहिए जो संकेत दे देंगे.

517
00:49:07,680 --> 00:49:11,510
मैं उन्हें रिक्त स्थान पर लिख देंगे.

518
00:49:11,510 --> 00:49:20,490
तो मुख्य लोगों में आप खुला और फिर च, अनिवार्य रूप से बंद कर दिया, च में देखना चाहता हूँ,

519
00:49:20,490 --> 00:49:26,540
जो अपने कार्यक्रम के अंत में जाना जाएगा, और च स्कैन च.

520
00:49:26,540 --> 00:49:31,060
तुम भी उपयोग कर सकता है च पढ़ने के, लेकिन आप शायद नहीं करना चाहती

521
00:49:31,060 --> 00:49:34,200
कि क्योंकि आप नहीं कि की आवश्यकता होगी, अंत नहीं है.

522
00:49:34,200 --> 00:49:41,880
F स्कैन च है कि तुम क्या करने के लिए शब्दकोश स्कैन का उपयोग करने के लिए होने जा रहे हैं.

523
00:49:41,880 --> 00:49:46,370
और इसलिए आप समाधान कोड की जरूरत नहीं है, बस कोशिश करते हैं और छद्म कोड की तरह अपना रास्ता

524
00:49:46,370 --> 00:50:05,200
एक समाधान के लिए, और फिर हम यह चर्चा करेंगे.

525
00:50:05,200 --> 00:50:14,110
और वास्तव में, जब से मैं पहले से ही आप इन दिया, अगर आप किसी भी टर्मिनल या अपने उपकरण खोल में जाना,

526
00:50:14,110 --> 00:50:18,250
मैं - मैं आमतौर पर अगर आप अभी तक नहीं देखा है, मैं जानता हूँ कि नहीं अगर आप वर्ग में किया था,

527
00:50:18,250 --> 00:50:23,490
लेकिन आदमी है, तो आदमी पृष्ठों, बहुत ज़्यादा किसी भी समारोह में देखने के लिए बहुत उपयोगी हैं.

528
00:50:23,490 --> 00:50:27,330
तो मुझे क्या करना, पसंद है, आदमी च, स्कैन च.

529
00:50:27,330 --> 00:50:32,300
इस अब कार्यों की स्कैन च परिवार के बारे में जानकारी है.

530
00:50:32,300 --> 00:50:37,070
मैं भी आदमी च, खुला कर सकता है, और कहा कि मुझे उस की जानकारी दे देंगे.

531
00:50:37,070 --> 00:50:40,750
तो अगर आप जानते हैं कि क्या तुम समारोह का उपयोग कर रहे हैं, या आप कोड को पढ़ रहे हैं

532
00:50:40,750 --> 00:50:43,000
और आप कुछ कार्य देखते हैं और आप कर रहे हैं जैसे, "यह क्या करता है?"

533
00:50:43,000 --> 00:50:45,280
बस आदमी समारोह कि नाम.

534
00:50:45,280 --> 00:50:47,340
अजीब उदाहरण के एक जोड़े हैं जहाँ आप करने के लिए कहने के लिए हो सकता है

535
00:50:47,340 --> 00:50:51,620
पसंद है. कि समारोह नाम, या 3 आदमी है कि समारोह का नाम, 2 आदमी

536
00:50:51,620 --> 00:50:58,230
लेकिन आप केवल करने की है कि अगर आदमी समारोह का नाम पहली बार काम करने के लिए नहीं होता है.

537
00:50:58,230 --> 00:51:03,010
[छात्र] तो मैं आदमी पृष्ठ के लिए खुला पढ़ रहा हूँ, लेकिन मैं अभी भी यह कैसे और प्रोग्राम का उपयोग करने पर उलझन में हूँ.

538
00:51:03,010 --> 00:51:06,170
ठीक है. आदमी पृष्ठों की एक बहुत मददगार की तुलना में कम कर रहे हैं.

539
00:51:06,170 --> 00:51:08,470
वे और अधिक उपयोगी हो अगर आप पहले से ही पता है कि वे क्या करते हैं

540
00:51:08,470 --> 00:51:12,670
और फिर तुम सिर्फ तर्क या कुछ के आदेश को याद करने की जरूरत है.

541
00:51:12,670 --> 00:51:17,640
या वे तुम्हें देने के लिए एक सामान्य अवलोकन कर सकते हैं, लेकिन उनमें से कुछ बहुत भारी हैं.

542
00:51:17,640 --> 00:51:22,220
च स्कैन च की तरह, यह भी. यह आप इन कार्यों में से सभी के लिए जानकारी देता है,

543
00:51:22,220 --> 00:51:28,120
और एक लाइन के नीचे यहाँ कहने के लिए होता है, "एफ स्कैन च स्ट्रिंग बिंदु या धारा से पढ़ता है."

544
00:51:28,120 --> 00:51:32,360
लेकिन खोलने के च. तो, हम च कैसे खुला प्रयोग करेंगे?

545
00:51:32,360 --> 00:51:38,470
एक कार्यक्रम के लिए जो फाइल करने की जरूरत का विचार मैं / हे है कि

546
00:51:38,470 --> 00:51:45,070
आप पहली बार आप के साथ काम करना चाहते हैं फ़ाइल खोलने की जरूरत है, और अनिवार्य रूप से,

547
00:51:45,070 --> 00:51:51,220
कि फ़ाइल से चीजों को पढ़ने के लिए और उन लोगों के साथ सामान करना.

548
00:51:51,220 --> 00:51:55,350
एफ खुला है कि हम क्या करने के लिए फ़ाइल खोलने के लिए उपयोग.

549
00:51:55,350 --> 00:52:04,190
बात हम वापस मिलता है, तो क्या हम फ़ाइल को खोलने के लिए चाहते हो, यह हमें देता है -

550
00:52:04,190 --> 00:52:11,970
यहाँ यह "/ उपयोगकर्ता / शेयर / dict / शब्द कहते हैं."

551
00:52:11,970 --> 00:52:16,740
इस फ़ाइल है कि हम खोलना चाहते है, और हम इसे खोलने के लिए करना चाहते हैं -

552
00:52:16,740 --> 00:52:21,440
हम स्पष्ट रूप से निर्दिष्ट कर सकते हैं कि क्या हम यह पढ़ने के लिए या यदि हम खोलना चाहते हैं, तो यह लिखने के लिए खोलना चाहते है.

553
00:52:21,440 --> 00:52:26,490
संयोजन और सामान की एक जोड़ी है, लेकिन हम पढ़ने के लिए खोलना चाहते हैं.

554
00:52:26,490 --> 00:52:29,380
हम फ़ाइल से पढ़ने के लिए करना चाहते हैं.

555
00:52:29,380 --> 00:52:34,290
तो इस वापसी क्या करता? यह एक फ़ाइल सितारे (*) देता है,

556
00:52:34,290 --> 00:52:37,260
और मैं सिर्फ चर च में सब कुछ है, तो * दिखाता हूँ,

557
00:52:37,260 --> 00:52:40,840
फिर, यह एक संकेत है, लेकिन हम संकेत के साथ सौदा नहीं करना चाहता है.

558
00:52:40,840 --> 00:52:46,470
तुम च के बारे में सोच के रूप में, च अब चर आप फ़ाइल प्रतिनिधित्व का उपयोग करने के लिए जा रहे हैं कर सकते हैं.

559
00:52:46,470 --> 00:52:49,850
तो अगर आप फ़ाइल से पढ़ने के लिए चाहते हैं, तो आप च से पढ़ा.

560
00:52:49,850 --> 00:52:54,820
यदि आप फ़ाइल को बंद करना चाहते हैं, तो आप च करीब है.

561
00:52:54,820 --> 00:53:00,350
तो जब कार्यक्रम के अंत में हम निश्चित रूप से फ़ाइल को बंद करना चाहते हैं, हम क्या करना चाहिए?

562
00:53:00,350 --> 00:53:06,750
हम च बंद करना चाहते हैं.

563
00:53:06,750 --> 00:53:12,600
तो अब पिछले फ़ाइल समारोह है कि हम करने के लिए उपयोग करना चाहते हैं के लिए जा रहे हैं, च च स्कैन च स्कैन है.

564
00:53:12,600 --> 00:53:20,930
और कि क्या करता है यह एक मैच के पैटर्न के लिए देख फ़ाइल पर स्कैन.

565
00:53:20,930 --> 00:53:39,100
आदमी पृष्ठ पर देख रहे हैं, हम int च स्कैन च देखते हैं, अब के लिए वापसी मूल्य की अनदेखी.

566
00:53:39,100 --> 00:53:45,230
1 तर्क फ़ाइल * धारा है, तो हम पारित करने के लिए चाहते करने जा रहे हैं 1 तर्क है च.

567
00:53:45,230 --> 00:53:47,900
हम च पर स्कैनिंग कर रहे हैं.

568
00:53:47,900 --> 00:53:53,680
दूसरा तर्क एक प्रारूप स्ट्रिंग है.

569
00:53:53,680 --> 00:53:58,310
मैं तुम्हें एक प्रारूप स्ट्रिंग सही अब दे देंगे.

570
00:53:58,310 --> 00:54:05,180
मुझे लगता है कि हम कहते हैं, 127s \ n, कि अनावश्यक है एक बहुत कुछ होता है.

571
00:54:05,180 --> 00:54:12,490
विचार की कि प्रारूप स्ट्रिंग क्या है, आप स्कैन च के प्रिंट च के विपरीत के रूप में सोच सकते हैं.

572
00:54:12,490 --> 00:54:17,160
तो प्रिंट च, प्रिंट च हम भी प्रारूप पैरामीटर का इस प्रकार का उपयोग करें,

573
00:54:17,160 --> 00:54:25,000
लेकिन प्रिंट च में हम क्या कर रहे हैं - चलो एक बराबर में देखो.

574
00:54:25,000 --> 00:54:32,550
तो च मुद्रित करने के लिए, और वास्तव में भी च च प्रिंट, जहां पहले तर्क च होने जा रहा है.

575
00:54:32,550 --> 00:54:40,980
जब तुम च मुद्रित करते हैं, हम कुछ की तरह कह सकते हैं, "प्रिंट 127s \ n" और फिर अगर हम इसे कुछ स्ट्रिंग पारित

576
00:54:40,980 --> 00:54:44,050
यह करने के लिए और फिर एक नई लाइन स्ट्रिंग प्रिंट जा रहा है.

577
00:54:44,050 --> 00:54:49,690
127 मतलब क्या, मैं बहुत यकीन है, लेकिन मैं खुद को यह करने के लिए कभी नहीं रखा है,

578
00:54:49,690 --> 00:54:52,470
तुम भी प्रिंट च में '127 'कहने की जरूरत नहीं होगी,

579
00:54:52,470 --> 00:54:57,090
लेकिन क्या इसका मतलब यह पहले 127 वर्ण मुद्रित है.

580
00:54:57,090 --> 00:54:59,350
तो मुझे पूरा यकीन है कि मामला है. तुम उस के लिए गूगल कर सकते हैं.

581
00:54:59,350 --> 00:55:03,000
लेकिन अगले एक में मैं लगभग सकारात्मक है इसका मतलब है कि हूँ.

582
00:55:03,000 --> 00:55:08,880
तो यह है कि पहले 127 वर्ण, एक नई लाइन के द्वारा पीछा प्रिंट.

583
00:55:08,880 --> 00:55:14,680
F स्कैन अब च, एक चर में देख रहे हैं और यह मुद्रण के बजाय,

584
00:55:14,680 --> 00:55:22,620
यह कुछ स्ट्रिंग को देखो, और चर में पैटर्न की दुकान के लिए जा रहा है.

585
00:55:22,620 --> 00:55:26,360
चलो वास्तव में एक अलग उदाहरण में स्कैन उपयोग च.

586
00:55:26,360 --> 00:55:31,670
तो चलो कहते हैं कि हम कुछ int था, x 4 =

587
00:55:31,670 --> 00:55:41,110
और हम एक से बना स्ट्रिंग बनाना चाहता था - स्ट्रिंग बनाना चाहता था

588
00:55:41,110 --> 00:55:44,250
कि जैसा था, यह बहुत बाद में आएगा,

589
00:55:44,250 --> 00:55:49,020
कुछ है कि 4.jpg की तरह है.

590
00:55:49,020 --> 00:55:51,870
तो यह एक कार्यक्रम है जहां आप राशि काउंटर होगा हो सकता है,

591
00:55:51,870 --> 00:55:56,420
मैं काउंटर राशि, और आप छवियों का एक गुच्छा बचाने के लिए चाहते हैं.

592
00:55:56,420 --> 00:56:02,430
तो आप i.jpg, जहां मैं अपने पाश की कुछ चलना है बचाने के लिए चाहते हैं.

593
00:56:02,430 --> 00:56:05,500
तो कैसे हम कि JPEG लिए इस स्ट्रिंग कर सकता हूँ?

594
00:56:05,500 --> 00:56:11,720
यदि आप 4.jpg मुद्रित करने के लिए करना चाहता था, हम सिर्फ प्रिंट, च% d.jpg कह सकते हैं,

595
00:56:11,720 --> 00:56:14,410
और फिर यह कि JPEG के लिए प्रिंट होगा.

596
00:56:14,410 --> 00:56:20,050
लेकिन अगर हम स्ट्रिंग 4.jpg को बचाने के लिए करना चाहते हैं, तो हम स्कैन च का उपयोग करें.

597
00:56:20,050 --> 00:56:30,860
स्ट्रिंग है तो वास्तव में हम can't - चरित्र, चार, 100 जाना.

598
00:56:30,860 --> 00:56:35,400
इसलिए मैं सिर्फ 100 अक्षरों के कुछ सरणी की घोषणा की है,

599
00:56:35,400 --> 00:56:39,830
और है कि हम क्या अनिवार्य रूप से करने के लिए कि JPEG भंडारण हो अंदर जा रहे हैं.

600
00:56:39,830 --> 00:56:47,920
तो हम स्कैन च का उपयोग करने के लिए जा रहे हैं, और स्वरूप है, कैसे हम% d.jpg कहना होगा

601
00:56:47,920 --> 00:56:54,980
4.jpg क्रम में मुद्रित करने के लिए, इस का प्रारूप% d.jpg होने जा रहा है.

602
00:56:54,980 --> 00:57:04,020
तो प्रारूप% d.jpg, हम साथ% d बदलना चाहते हैं क्या है x है,

603
00:57:04,020 --> 00:57:06,590
और अब हम उस स्ट्रिंग कहीं स्टोर की जरूरत है.

604
00:57:06,590 --> 00:57:12,500
और जहां हम इस स्ट्रिंग की दुकान करने के लिए जा रहे हैं सरणी है.

605
00:57:12,500 --> 00:57:21,640
तो कोड, एस के इस लाइन के बाद, अगर हम च, चर s के% s मुद्रित,

606
00:57:21,640 --> 00:57:26,280
यह 4.jpg मुद्रित करने के लिए जा रहा है.

607
00:57:26,280 --> 00:57:38,930
तो स्कैन च च स्कैन च के रूप में ही छोड़कर अब इस फाइल पर यह लग रहा है,

608
00:57:38,930 --> 00:57:43,600
क्या एस में संग्रहीत.

609
00:57:43,600 --> 00:57:46,160
यही अंतिम बहस के लिए क्या किया जा रहा है.

610
00:57:46,160 --> 00:57:54,170
कार्यों स्कैन के दोनों प्रारूप के अनुसार नीचे के रूप में करने की कोशिश की "स्कैन च परिवार हम स्टोर करने के लिए करना चाहते हैं.

611
00:57:54,170 --> 00:58:02,450
यदि किसी भी स्थान अंक में संग्रहित कर रहे हैं आप वापसी हो सकती है "

612
00:58:02,450 --> 00:58:12,910
नहीं, हम अच्छा हो सकता है. मुझे एक पल के लिए लगता है.

613
00:58:12,910 --> 00:58:26,350
क्या बिल्ली समारोह जो कि करता है तो स्कैन च नहीं करता है?

614
00:58:26,350 --> 00:58:31,650
तो स्कैन च एक पूर्णांक ले और डॉट jpg नहीं जा रहा है.

615
00:58:31,650 --> 00:58:43,490
यह [फुसफुसाता] करने के लिए जा रहा है.

616
00:58:43,490 --> 00:58:49,360
स्ट्रिंग int सी. में int चर सहेजें

617
00:58:49,360 --> 00:58:55,940
इस चर क्या है, या इस समारोह में क्या कहा जाता है?

618
00:58:55,940 --> 00:59:04,950
हां. That's - हाँ. तो क्या मैं आप को परिभाषित किया गया है से पहले एस प्रिंट च था,

619
00:59:04,950 --> 00:59:09,820
जो कि बहुत अधिक समझ में आता है, इसलिए मैंने कहा कि यह प्रिंट च की तरह ज्यादा था बनाता है.

620
00:59:09,820 --> 00:59:14,700
स्कैन च अभी भी प्रिंट च की तरह की तरह है, लेकिन एस प्रिंट च इसे स्कैन पर जा रहा है

621
00:59:14,700 --> 00:59:17,510
और चर की जगह है और अब यह एक स्ट्रिंग में संग्रहीत.

622
00:59:17,510 --> 00:59:19,620
यह मुद्रण के बजाय, यह एक स्ट्रिंग में संग्रहीत करता है.

623
00:59:19,620 --> 00:59:25,070
तो यह है कि पूरी तरह से की उपेक्षा. अभी भी आप की तरह है कि प्रिंट च के रूप में प्रारूप विनिर्देशक के बारे में सोच सकते हैं.

624
00:59:25,070 --> 00:59:34,510
तो अब, अगर हम 4.jpg बात करना चाहता था, हम है प्रिंट च करते हैं, इस के एक्स.

625
00:59:34,510 --> 00:59:38,520
तो स्कैन च क्या कर रहा है - क्या अपने प्रश्न के लिए होने जा रहा है?

626
00:59:38,520 --> 00:59:40,820
[छात्र] मैं बस क्या हम यहीं करने की कोशिश कर रहे हैं पर उलझन में हूँ

627
00:59:40,820 --> 00:59:43,450
कि JPEG के साथ. आपको लगता है कि 1 और अधिक समय की व्याख्या कर सकते हैं?

628
00:59:43,450 --> 00:59:52,710
तो यह था - यह कम च स्कैन अब च के लिए प्रासंगिक है, उम्मीद है, इसे वापस रास्ते से किसी तरह का में टाई जाएगा.

629
00:59:52,710 --> 01:00:02,240
लेकिन मैं शुरू करने के लिए दिखाने के लिए इरादा था क्या था - यह वास्तव में सीधे इन [प्रासंगिक है? F5]

630
01:00:02,240 --> 01:00:08,520
आप एस प्रिंट च का उपयोग करने के लिए होने जा रहे हैं, जहां का कहना है, हम 100 चित्र है,

631
01:00:08,520 --> 01:00:13,630
और आप छवि 1.jpg 2.jpg, 3.jpg पढ़ने के लिए चाहते हैं.

632
01:00:13,630 --> 01:00:21,520
तो आदेश में करने के लिए है कि, आप च के लिए खुला है की जरूरत है, और फिर तुम स्ट्रिंग जिसे आप खोलना चाहते हैं में पारित किया है.

633
01:00:21,520 --> 01:00:30,020
तो हम 1.jpg खोलने के लिए चाहते हैं, क्रम में स्ट्रिंग 1.jpg है कि बनाने के लिए,

634
01:00:30,020 --> 01:00:37,660
हम% की प्रिंट च d.jpg हम int i = 0 के लिए क्या किया.

635
01:00:37,660 --> 01:00:46,580
मैं 40 <, मैं + +.

636
01:00:46,580 --> 01:00:51,130
तो प्रिंट च% मैं के d.jpg.

637
01:00:51,130 --> 01:00:56,320
तो इस लाइन के बाद, अब चर या सरणी 1.jpg जा रहा है.

638
01:00:56,320 --> 01:01:10,610
या, 0.jpg, 1.jpg 2.jpg. और इसलिए हम, बारी में खोलने के लिए, पढ़ने के लिए प्रत्येक छवि कर सकते हैं.

639
01:01:10,610 --> 01:01:19,550
तो यह है कि एस क्या च मुद्रित करने के लिए करता है. क्या आप देख एस क्या च अब कर रही है मुद्रित करने के लिए?

640
01:01:19,550 --> 01:01:25,720
[छात्र] ठीक है, तो इसे ले जा रही है - यह एक स्ट्रिंग बनाता है, something.jpg, और फिर यह भंडार.

641
01:01:25,720 --> 01:01:30,360
हां. यह बनाता है - यह एक और प्रारूप स्ट्रिंग स्कैन च और प्रिंट च की तरह है,

642
01:01:30,360 --> 01:01:37,530
जहां दूसरा तर्क में यह चर के सभी आवेषण, के रूप में मैं विरोध हो सकता है.

643
01:01:37,530 --> 01:01:42,280
शायद मेरा मतलब है, यह मामला है. लेकिन जो कुछ तर्कों के आदेश है.

644
01:01:42,280 --> 01:01:45,440
यह प्रारूप स्ट्रिंग में चर के सभी डालने जा

645
01:01:45,440 --> 01:01:52,250
और फिर हमारे बफर में दुकान, हम कहते हैं कि एक बफर, यह है जहाँ हम स्ट्रिंग भंडारण कर रहे हैं.

646
01:01:52,250 --> 01:02:00,750
तो हम एस के अंदर भंडारण कर रहे हैं सही ढंग से स्वरूपित स्ट्रिंग,% d 4 के साथ प्रतिस्थापित किया गया है.

647
01:02:00,750 --> 01:02:08,080
[छात्र] तो अगर हम यह किया है, चर च बस फिर नियत किया जा रहा है?

648
01:02:08,080 --> 01:02:18,110
हां. तो हम ऐसा करने से पहले मूल च बंद हो जाना चाहिए.

649
01:02:18,110 --> 01:02:22,810
पर - और फिर भी, अगर वहाँ एक च यहाँ खोलने नहीं थे, तो हम कहने के लिए की आवश्यकता होगी -

650
01:02:22,810 --> 01:02:29,280
हाँ. लेकिन यह एक सौ अलग अलग फ़ाइलों को खोलने का होगा.

651
01:02:29,280 --> 01:02:37,360
ठीक [छात्र] लेकिन हम तक पहुँच या करने में सक्षम नहीं होगा.

652
01:02:37,360 --> 01:02:44,230
ठीक है. स्कैन च, च स्कैन च, तो एक ही विचार की तरह है,

653
01:02:44,230 --> 01:02:53,610
लेकिन इसके बजाय, यह एक स्ट्रिंग में भंडारण के बजाय, यह तुम अब कर रहे हैं और अधिक की तरह है

654
01:02:53,610 --> 01:03:02,420
एक डंक और पैटर्न कि स्ट्रिंग के खिलाफ मिलान पर जा रहा है और चर में परिणाम भंडारण.

655
01:03:02,420 --> 01:03:11,290
आप स्कैन उपयोग च 4.jpg की तरह कुछ पर पार्स, और राशि int x में पूर्णांक 4 की दुकान कर सकते हैं.

656
01:03:11,290 --> 01:03:13,430
यही कारण है कि हम क्या के लिए स्कैन च का उपयोग कर सकते हैं.

657
01:03:13,430 --> 01:03:16,300
F स्कैन च कि कमांड लाइन पर करने जा रहा है.

658
01:03:16,300 --> 01:03:19,200
मैं वास्तव में पूरा यकीन है कि यह क्या CS50 पुस्तकालय करता हूँ.

659
01:03:19,200 --> 01:03:29,050
तो जब आप कहते हैं, ", int हो" यह खत्म हो च आईएनजी स्कैन - स्कैन च जिस तरह से आप उपयोगकर्ता इनपुट मिलता है.

660
01:03:29,050 --> 01:03:34,670
F स्कैन च के लिए एक ही बात कर रहा है, लेकिन एक फ़ाइल का उपयोग करने पर स्कैन.

661
01:03:34,670 --> 01:03:41,090
तो, यहाँ हम इस फाइल पर स्कैनिंग कर रहे हैं.

662
01:03:41,090 --> 01:03:45,460
पैटर्न हम मैच की कोशिश कर रहे हैं कि 127 वर्ण लंबा है कुछ स्ट्रिंग है

663
01:03:45,460 --> 01:03:48,100
एक नई लाइन के द्वारा पीछा

664
01:03:48,100 --> 01:03:54,770
तो मुझे यकीन है कि हम भी कह सकते हैं "मैच" के बाद से इस शब्दकोश में

665
01:03:54,770 --> 01:03:57,770
हम के लिए होता है, हम गारंटी रहे हैं कोई शब्द नहीं है कि लंबे समय है,

666
01:03:57,770 --> 01:04:03,310
और भी च स्कैन च नई लाइन पर मुझे लगता है, कोई बात नहीं क्या बंद हो जाएगा.

667
01:04:03,310 --> 01:04:06,970
लेकिन हम मैच में नई लाइन को शामिल करेंगे, और -

668
01:04:06,970 --> 01:04:13,960
[छात्र] अगर हम नई लाइन को शामिल नहीं किया है, तो यह एक शब्द के कुछ हिस्सों को नहीं मिल जाएगा?

669
01:04:13,960 --> 01:04:22,900
प्रत्येक - यह शब्दकोश में देख रहे हैं -

670
01:04:22,900 --> 01:04:26,200
शब्दकोश में तो, ये हमारे शब्दों के सभी कर रहे हैं.

671
01:04:26,200 --> 01:04:30,500
हर एक को एक नई लाइन पर है.

672
01:04:30,500 --> 01:04:32,510
स्कैन च करने के लिए इस शब्द के लेने के लिए जा रहा है.

673
01:04:32,510 --> 01:04:38,750
यदि हम नई लाइन शामिल नहीं है, तो यह संभव है कि अगले स्कैन च सिर्फ नई लाइन पढ़ा होगा.

674
01:04:38,750 --> 01:04:44,180
लेकिन नई लाइन सहित तो सिर्फ नई लाइन की अनदेखी करेंगे.

675
01:04:44,180 --> 01:04:49,440
लेकिन हम कभी भी एक शब्द का हिस्सा नहीं मिलता है, क्योंकि हम हमेशा एक नई लाइन के लिए पढ़ने, कोई बात नहीं क्या होगा.

676
01:04:49,440 --> 01:04:54,530
[छात्र] लेकिन क्या अगर आप शब्द "cissa," cissa तरह के लिए खोज.

677
01:04:54,530 --> 01:04:57,380
यह है कि मिल जाएगा, और कहते हैं कि यह एक मैच है?

678
01:04:57,380 --> 01:05:05,110
यहाँ तो हम - यह में पढ़ा होगा - यह वास्तव में एक अच्छी बात है.

679
01:05:05,110 --> 01:05:10,660
हम वर्तमान कभी नहीं का उपयोग कर रहे हैं - शब्द के लिए हम देख रहे हैं 1 कमांड लाइन तर्क है.

680
01:05:10,660 --> 01:05:16,460
तो स्ट्रिंग, शब्द = 1 argv.

681
01:05:16,460 --> 01:05:20,020
तो स्ट्रिंग के लिए हम देख रहे हैं 1 argv है.

682
01:05:20,020 --> 01:05:23,290
हम हमारे स्कैन च सब पर एक शब्द के लिए नहीं देख रहे हैं.

683
01:05:23,290 --> 01:05:28,030
क्या हम स्कैन च के साथ कर रहे थे शब्दकोश में प्रत्येक शब्द हो रही है,

684
01:05:28,030 --> 01:05:34,320
और फिर एक बार हम हम strcmp का उपयोग करने के लिए उनकी तुलना करने के लिए जा रहे हैं कि शब्द है.

685
01:05:34,320 --> 01:05:39,210
हम हमारे शब्द की तुलना करने के लिए जा रहे हैं और हम क्या सिर्फ अंदर पढ़ें

686
01:05:39,210 --> 01:05:45,110
तो अनिवार्य रूप से, हम करने के लिए अंत स्कैन एफएस की एक गुच्छा कर जा रहे हैं

687
01:05:45,110 --> 01:05:52,130
जब तक यह सिर्फ इतना होता है कि स्कैन च वापस आ जाएगी -

688
01:05:52,130 --> 01:05:54,800
यह एक लौटने के लिए, के रूप में लंबे समय के रूप में यह एक नया शब्द मिलान किया जाएगा,

689
01:05:54,800 --> 01:06:01,360
और यह कुछ और जैसे ही यह शब्द मैच में विफल रहा है वापस आ जाएगी.

690
01:06:01,360 --> 01:06:08,440
हम पूरे शब्दकोश पर पढ़ रहे हैं, लाइन से लाइन प्रत्येक शब्द भंडारण चर s में.

691
01:06:08,440 --> 01:06:17,240
तब हम एस के साथ शब्द की तुलना कर रहे हैं, और अगर तुलना == 0

692
01:06:17,240 --> 01:06:21,650
strcmp 0 लाने के लिए अगर एक मैच बनाया गया था होता है.

693
01:06:21,650 --> 01:06:31,510
तो अगर यह 0 गया था, तो हम च मुद्रित करने के लिए, मिलान किया जा सकता है,

694
01:06:31,510 --> 01:06:35,370
या शब्द शब्दकोश में है, या जो कुछ भी आप च मुद्रित करना चाहते हैं.

695
01:06:35,370 --> 01:06:41,450
और फिर हम च पर बंद करो और पर फिर से नहीं करना चाहती.

696
01:06:41,450 --> 01:06:50,410
इस बात की तरह हम करना चाहते है, और हम सिर्फ शब्दकोश में शब्द के लिए नहीं देख रहे हैं.

697
01:06:50,410 --> 01:06:56,660
तो हम करते हैं, अगर हम अपने पैटर्न, cissa के लिए देखना चाहता था सकता है, जैसे पहले कहा,

698
01:06:56,660 --> 01:07:00,260
अगर हम उस पैटर्न के लिए देखना चाहता था, तो यह मामले में विफल हो जाएगा

699
01:07:00,260 --> 01:07:08,010
कि वास्तव में एक शब्द भी नहीं है, लेकिन क्योंकि एक शब्दकोश में शब्दों की यह है कि होता है.

700
01:07:08,010 --> 01:07:13,560
तो यह शब्द इस मैच के लिए, लेकिन इस शब्द का सबसेट एक शब्द ही नहीं है.

701
01:07:13,560 --> 01:07:17,250
लेकिन यह है कि कैसे हम इसे प्रयोग नहीं कर रहे है, हम प्रत्येक शब्द में पढ़ रहे हैं

702
01:07:17,250 --> 01:07:19,740
और फिर हम उस शब्द के साथ शब्द की तुलना.

703
01:07:19,740 --> 01:07:25,780
तो हम हमेशा पूर्ण शब्दों की तुलना कर रहे हैं.

704
01:07:25,780 --> 01:07:29,620
मैं अंतिम रूप दिया समाधान बाद में भेज सकते हैं.

705
01:07:29,620 --> 01:07:32,050
यह लगभग सही जवाब की तरह है, मुझे लगता है.

706
01:07:32,050 --> 01:07:34,720
[छात्र टिप्पणी, unintelligible]

707
01:07:34,720 --> 01:07:40,870
ओह, मैं उससे छुटकारा पाना था पहले? चार है, मुझे लगता है कि हम 127 ने कहा - मैं भूल जाते हैं सबसे बड़ा क्या है.

708
01:07:40,870 --> 01:07:44,100
हम सिर्फ 128 करूँगा, तो अब लंबे समय पर्याप्त है.

709
01:07:44,100 --> 01:07:46,570
हम कुछ भी मुद्रित करने की जरूरत नहीं है.

710
01:07:46,570 --> 01:07:56,440
हम भी हमारे फाइल को बंद करने के लिए है चाहता हूँ के लिए जा रहे हैं, और है कि सही जवाब के बारे में होना चाहिए.

711
01:07:56,440 --> 01:07:59,440
CS50.TV