>> ZAMYLA चान: चलो एक जादू चेकर.
आप speller.c खोलते हैं, तो आप देखेंगे उस के लिए कार्यक्षमता के सबसे
एक के खिलाफ एक पाठ फ़ाइल की जाँच शब्दकोश पहले से ही आप के लिए किया जाता है.
एक शब्दकोश पाठ में गुजर रहा है. / स्पेलर, फ़ाइल और फिर एक और पाठ फ़ाइल,
उस पाठ फ़ाइल की जाँच करेगा शब्दकोश के खिलाफ.
>> अब, शब्दकोश पाठ फ़ाइलों में शामिल होंगे वैध शब्द, एक प्रति पंक्ति.
फिर speller.c लोड भेंट करेंगे शब्दकोश पाठ फ़ाइल पर.
यह कहा जाता है एक समारोह पर जाँच बुलाता हूँ inputted पाठ फ़ाइल में हर शब्द,
सब गलत वर्तनी शब्दों मुद्रण.
>> Speller.c भी करने साइज भेंट करेंगे में शब्दों की संख्या का निर्धारण
शब्दकोश और कॉल अनलोड स्मृति को मुक्त करने के लिए.
speller.c भी कैसे की नज़र रखेंगे ज्यादा समय इनमें से संचालन करने के लिए प्रयोग किया जाता है
प्रक्रियाओं, लेकिन हम करेंगे बाद में उस करने के लिए मिलता है.
>> तो क्या हम ऐसा करने की क्या ज़रूरत है?
हम dictionary.c में भरने की जरूरत है.
Dictionary.c में, हम सहायक है जो भार समारोह लोड,
शब्दकोश.
अगर जाँच करता है जो समारोह की जांच, दिया गया शब्द शब्दकोश में है.
समारोह साइज संख्या देता है शब्दकोश में शब्द की.
और अंत में, हम, उतारना है जो स्मृति से शब्दकोश मुक्त कर देते हैं.
>> तो सबसे पहले, के लोड से निपटने.
शब्दकोश पाठ में प्रत्येक शब्द के लिए फ़ाइल, लोड में उन शब्दों की दुकान होगी
शब्दकोश डेटा संरचना अपने चयन, या तो एक की
तालिका या एक Trie हैश.
मैं में दोनों पर जायेंगे इस के माध्यम से चलते हैं.
>> पहले हम हैश तालिकाओं के बारे में बात करते हैं.
आप 10 गेंदों बिलियर्ड था और कहो आप उन्हें स्टोर करना चाहता था.
आप एक बाल्टी में डाल सकता है, और आप एक विशिष्ट जब जरूरत
गेंद गिने, तुम एक ले लेनी चाहिए एक समय में बाल्टी से बाहर
उस गेंद की तलाश में.
और केवल 10 गेंदों के साथ, आप होना चाहिए एक उचित में अपनी गेंद खोजने के लिए सक्षम
समय की राशि है.
>> लेकिन क्या आप 20 गेंदों था?
अब यह एक छोटे से लंबे समय लग सकता है.
क्या 100 के बारे में?
1000?
अब, यह बहुत आसान हो जाएगा अगर आप कई बाल्टी था.
शायद गेंदों के लिए एक बाल्टी शून्य गिने नौ, के लिए एक और बाल्टी के माध्यम से
गेंदों के माध्यम से 10 गिने 19, और इतने पर.
>> अब आप विशिष्ट लिए देखने के लिए जब जरूरत गेंद, आप स्वचालित रूप से कर सकते थे
एक विशिष्ट बाल्टी में जाना और उस बाल्टी के माध्यम से खोज.
और प्रत्येक बकेट लगभग 10 है अगर गेंदों, तो आप आसानी से खोज सकते हैं
इसके माध्यम से.
>> अब, हम साथ काम कर रहे हैं के लिए शब्दकोशों, एक ही बाल्टी
शब्दकोश में शब्द के सभी करेंगे शायद अब तक बहुत कुछ बाल्टी हो.
तो चलो हैश टेबल पर एक नजर डालते हैं.
>> बाल्टी की एक सरणी के रूप में सोचो.
और इस मामले में, बाल्टी हमारे लिंक सूचियों हैं.
और हम अपने शब्दों के सभी वितरित करेंगे इन कई लिंक सूचियों में लोगों के बीच
एक हैश समारोह का उपयोग कर एक संगठित तरीके से, हमें बताना होगा कि जो जो
एक दिया कुंजी बाल्टी, एक दिया शब्द, के अंतर्गत आता है.
>> के रेखाचित्र के रूप में इस का प्रतिनिधित्व करते हैं.
यहाँ नीले बॉक्स मान हैं और लाल बक्से एक और मूल्य के लिए बिंदु
सूचक जोड़ी.
हम इन जोड़ों नोड्स फोन करता हूँ.
अब, एक बाल्टी, के रूप में मैंने कहा था इससे पहले, एक लिंक सूची है.
लिंक सूचियों में, प्रत्येक नोड एक मूल्य है, साथ ही एक सूचक
अगले मूल्य.
>> अब, लिंक सूचियों के साथ काम कर, यह बहुत महत्वपूर्ण है कि आप उस
किसी भी लिंक नहीं खोना है.
और याद करने की एक और तथ्य यह है कि पिछले नोड, यह इंगित नहीं करता है अगर
अन्य नोड, अशक्त करने के लिए अंक.
>> तो हम कैसे सी में इस का प्रतिनिधित्व करते हैं?
हम यहाँ हमारी संरचना को परिभाषित.
और इस मामले में मूल्य है लंबाई की एक चार सरणी.
लंबाई है जहां लंबाई प्लस 1, अधिकतम किसी भी शब्द की लंबाई, प्लस 1 के लिए
अशक्त टर्मिनेटर.
और फिर हम करने के लिए एक सूचक है अगला नामक एक और नोड.
>> तो चलो एक छोटा सा लिंक सूची बनाते हैं.
सबसे पहले, आप अपने नोड malloc के लिए चाहता हूँ, स्मृति में स्थान बनाने के जो
अपने नोड प्रकार के आकार.
और एक और नोड बनाने, फिर mallocing.
>> अब आप एक के लिए एक मूल्य प्रदान करना चाहते हैं शब्द, तो हम Node1 तीर कह सकते हैं
शब्द "नमस्ते." के बराबर होती है यह तीर ऑपरेटर सूचक और dereferences
संरचना के चर तक पहुँचता है.
इस तरह, हम दोनों का उपयोग करने के लिए नहीं है डॉट और सितारा ऑपरेटर.
>> तो फिर मैं Node2 तीर शब्द के बराबर होती है "दुनिया." और वहाँ है, मान रहे हैं
मेरे नोड्स में बसा.
लिंक बनाने के लिए, मैं Node1 में पारित करेंगे अगले तीर, कि नोड सितारा पहुँचने,
कि नोड सूचक, Node2 के बराबर होती है, दो Node2 को Node1 ओर इशारा करते हुए.
और वहाँ हम एक लिंक सूची है.
>> तो यह है कि सिर्फ एक लिंक की गई सूची में था, लेकिन एक हैश तालिका की एक पूरी सरणी है
लिंक सूचियों.
ठीक है, हम एक ही नोड होगा पहले के रूप में की संरचना करें.
लेकिन हम एक वास्तविक हैश तालिका चाहता था, तो हम सिर्फ एक नोड सूचक बना सकते हैं
यहाँ सरणी.
उदाहरण के लिए, आकार 500.
>> अब नोटिस, एक व्यापार होने जा रहा है के आकार के बीच से अपने
हैश तालिका और आकार अपने लिंक सूचियों की.
आप में से एक बहुत उच्च संख्या है, तो बाल्टी, वापस चलाने के लिए होने की कल्पना
और आगे के लिए एक पंक्ति में अपने बाल्टी लगता है.
लेकिन आप भी एक छोटी संख्या नहीं करना चाहती बाल्टी की, तो हम करने के लिए वापस आ गए हैं क्योंकि
होने कैसे की मूल समस्या हमारे बाल्टी में भी कई गेंदों.
>> ठीक है, लेकिन जहां हमारे गेंद जाना है?
खैर, हम पहले करने की जरूरत है सही, एक गेंद है?
तो चलो हर के लिए एक नोड malloc जाने हम हैं कि नए शब्द.
नोड * new_node बराबरी malloc (sizeof (नोड)).
>> हम इस संरचना है अब कि, हम समारोह का उपयोग कर, में स्कैन कर सकते हैं
fscanf, हमारे फ़ाइल से एक स्ट्रिंग, अगर उस में, एक शब्दकोश फ़ाइल है
new_node तीर शब्द, जहां new_node तीर शब्द हमारी है
उस शब्द का गंतव्य.
>> अगला, हम उस हैश करने के लिए चाहता हूँ एक हैश समारोह का उपयोग कर शब्द.
एक हैश समारोह एक स्ट्रिंग लेता है और एक सूचकांक देता है.
इस मामले में, सूचकांक करने के लिए है की संख्या की तुलना में कम हो
है कि आप बाल्टी.
>> अब, हैश कार्यों, तुम कोशिश कर रहे हैं एक पाते हैं और में से एक बनाने के लिए
अपनी खुद की, याद है कि वे नियतात्मक रहना होगा.
वह उसी मूल्य की जरूरत है कि इसका मतलब है एक ही बाल्टी के लिए हर समय नक्शा
आप यह हैश कि.
>> यह एक तरह से एक पुस्तकालय की तरह है.
आप पर आधारित एक पुस्तक, जब ले लेखक, तुम्हें पता है जो शेल्फ यह चाहिए
यह शेल्फ संख्या चाहे, पर जाना एक, दो, या तीन.
और उस किताब हमेशा पर होगी शेल्फ एक, दो, या तीन या तो.
>> तो, अगर new_node तीर शब्द है अपने शब्दकोश से शब्द, तो
hashing new_node तीर शब्द होगा हम में से सूचकांक दे
हैश तालिका की बाल्टी.
और फिर हम उस में उस डालने देंगे ने संकेत दिया विशिष्ट लिंक सूची
हमारे हैश समारोह के मूल्य वापसी.
>> का एक उदाहरण में देखें में एक नोड डालने
एक लिंक की गई सूची की शुरुआत.
सिर इंगित करता है कि एक नोड सूचक है तो किसी लिंक किए की शुरुआत
सूची, और new_node नया इंगित करता है आप बस में प्रवेश करना चाहते हैं कि नोड
new_node को सिर बताए खो देगा सूची के आराम करने के लिए लिंक.
तो हम ऐसा करने के लिए नहीं करना चाहती.
>> बल्कि, हम यह सुनिश्चित करना चाहते हैं हम हर पर पकड़ कि
हमारे कार्यक्रम में एकल नोड.
तो चल new_node तीर अगला बराबरी सिर और फिर सिर new_node के बराबर होती है
के सभी की रक्षा करेंगे लिंक और किसी भी खोना नहीं.
>> लेकिन अगर आप अपनी सूची में होना करने के लिए क्या चाहते हैं एक क्रमबद्ध जुड़ा हुआ होने की वजह से, हल
सूची के लिए आसान हो सकता है पर बाद में यह खोज?
खैर, उस के लिए, आपको पता है की आवश्यकता होगी कैसे लिंक सूचियों पार करने के लिए.
>> एक लिंक की गई सूची पार करने के लिए, चलो करते हैं के रूप में कार्य करने के लिए एक नोड सूचक, एक नोड *
यह दर्शाता अपने कर्सर, जो आप शुरू, पर कर रहे हैं नोड
पहला तत्व में.
कर्सर जब तक पाशन हम कर सकते हैं, अशक्त है फिर कुछ प्रक्रियाओं और आचरण
जरूरत है कि हम जब कर्सर अग्रिम कर्सर तीर मूल्य का उपयोग कर.
>> याद रखें, इस के रूप में एक ही बात है dereferencing, सितारा कर्सर कह
तब का उपयोग, कर्सर डॉट ऑपरेटर मूल्य.
तो बताए द्वारा कर्सर है अद्यतन करने अगले कर्सर तीर कर्सर.
>> आप डी में हो जाता है कि निर्धारित कहो सी और ई नोड सम्मिलित करने के बीच,
को new_node डी बिंदु है अगले कर्सर है जो नोड ई,.
और फिर सी, कर्सर, तो बात कर सकते हैं डी. कि जिस तरह से करने के लिए, आप एक सूची बनाए.
द्वारा अपने लिंक खोना नहीं सावधान रहो अगले डी के लिए कर्सर तीर आगे बढ़
सही दूर.
>> ठीक है.
तो यह है कि, आप नोड्स सम्मिलित हो सकता है कैसे उन में, भार शब्द उन में लोड
नोड्स, और उन्हें सम्मिलित अपने हैश तालिका में.
तो अब की कोशिश करता है पर देखो.
>> एक Trie में, हर नोड एक में शामिल होंगे नोड संकेत, हर एक के लिए की सरणी
वर्णमाला में अक्षर प्लस एक apostrophe.
और सरणी में प्रत्येक तत्व अन्य नोड के लिए बात करेंगे.
कि नोड अशक्त, तो उस पत्र है तो अगले पत्र के नहीं होने जा रहा है
एक दृश्य में किसी भी शब्द, क्योंकि हर शब्द यह पिछले है कि क्या इंगित करता है
एक शब्द या नहीं का चरित्र.
>> के एक चित्र में देखें.
उम्मीद है कि चीजें होगा एक सा साफ हो.
इस चित्र में, हम देखते हैं कि केवल कुछ पत्र और कुछ substrings
बाहर सूचीबद्ध किया जा रहा है.
तो आप निश्चित पथ का अनुसरण कर सकते हैं और उन रास्तों की सभी को बढ़ावा मिलेगा
अलग शब्द.
>> तो हम कैसे सी में इस का प्रतिनिधित्व करते हैं?
खैर, हर नोड अब किया जा रहा है चाहे का संकेत एक बूलियन मान
कि नोड के अंत है दिया गया शब्द या नहीं.
और फिर यह भी की एक सरणी होगा नोड बच्चों को बुलाया संकेत, और
उनमें से 27 होने के लिए वहाँ जा रहे हैं.
और तुम भी करने के लिए चाहता हूँ, याद अपना पहला नोड का ट्रैक रखने.
हम उस रूट कॉल करने के लिए जा रहे हैं.
>> इसलिए कि एक Trie की संरचना है.
कैसे हम इस का प्रतिनिधित्व करते हैं एक शब्दकोश के रूप में?
खैर, हर एक के लिए, में शब्दों को लोड करने के लिए शब्दकोश शब्द, तुम चाहते हो जा रहे हैं
Trie के माध्यम से पुनरावृति करने के लिए.
और बच्चों में प्रत्येक तत्व एक अलग पत्र से मेल खाती है.
>> इसलिए बच्चों पर मूल्य की जाँच मैं प्रतिनिधित्व करता है जहां सूचकांक मैं,
पत्र के विशिष्ट सूचकांक कि आप सम्मिलित करने के लिए कोशिश कर रहे हैं.
खैर, यह शून्य है, तो आप के लिए चाहता हूँ एक नए नोड malloc और बच्चे हैं
मुझे लगता है कि नोड के लिए इशारा करते हैं.
>> यह रिक्त नहीं है, तो इसका मतलब है कि यह देखते हुए कि शाखा, यह देखते हुए कि
substring, पहले से मौजूद है.
तो फिर आप सिर्फ इतना है कि करने के लिए कदम होगा नए नोड और जारी है.
तुम शब्द के अंत में कर रहे हैं कि आप में लोड करने के लिए कोशिश कर रहे हैं
शब्दकोश, तो आपको लगता है कि सेट कर सकते हैं आप सच कह रहे हैं कि वर्तमान नोड.
>> तो चलो डालने का एक उदाहरण को देखो में शब्द "फॉक्स" हमारा
शब्दकोश.
हम साथ शुरू बहाना एक खाली शब्दकोश.
पहले अक्षर, एफ, स्थित हो जाएगा बच्चों के सूचकांक में जड़ों के पांच
बच्चों सरणी.
तो हम अंदर उस डालने
>> पत्र हे तो बच्चों में होगा फिर उस एफ के बाद सूचकांक 15, और एक्स
शाखाओं में बंटी, यह भी है कि नीचे हो जाएगा हे के बच्चों से दूर.
और फिर एक्स आखिरी खत है क्योंकि शब्द का "फॉक्स," तो मैं करने जा रहा हूँ
इंगित करने के लिए कि हरे रंग कि यह शब्द के अंत में है.
सी में, यह है कि स्थापित हो जाएगा शब्द सच मान पर बूलियन.
>> अब क्या हुआ अगर आप कर रहे हैं कि अगले शब्द में लोड करने के लिए शब्द "foo" है?
वैसे, अगर आप किसी भी अधिक malloc की जरूरत नहीं है एफ के लिए या ओ के लिए अंतरिक्ष, क्योंकि
उन पहले से मौजूद हैं.
लेकिन foo में पिछले हे?
एक है कि आप malloc के लिए होगा.
सेटिंग, उस के लिए एक नया नोड बनाओ सच है पद बूलियन.
>> तो अब सम्मिलित करते हैं "कुत्ता." डॉग होगा जड़ों के सूचकांक तीन के साथ शुरू
बच्चों, डी नहीं है क्योंकि अभी तक नहीं बनाया गया.
और हम एक ऐसी प्रक्रिया के रूप में पालन करेंगे इससे पहले, substring कुत्ते बनाने,
जहां जी हरी क्योंकि रंग का है कि एक शब्द के अंत में है.
>> अब, हम "नहीं" सम्मिलित करने के लिए क्या चाहते हैं?
खैर, इस कुत्ते का एक substring है, तो हम अब और malloc की जरूरत नहीं है.
लेकिन हम हम है जहां संकेत की जरूरत है उस शब्द के अंत पर पहुंच गया.
तो हे हरे रंग का हो जाएगा.
हर एक के लिए है कि प्रक्रिया जारी अपने शब्दकोश में शब्द, आपने
या तो अपने में में उन्हें भरा हुआ तालिका या अपने Trie हैश.
>> speller.c के लिए तार में समाप्त हो जाएगी उन्हें जांच के लिए dictionary.c.
अब, जाँच समारोह को संचालित करने के लिए है मामले असंवेदनशीलता के तहत.
इसका मतलब है कि राजधानी पत्र और छोटे अक्षरों और दोनों का मिश्रण
सब सच करने के लिए समान होना चाहिए, यदि कोई हो उस के संयोजन में है
शब्दकोश.
तुम भी तार कर रहे हैं कि कल्पना कर सकते हैं केवल वर्णमाला होते जा रहा
वर्ण या apostrophes.
>> तो चलो आप जाँच कर सकते हैं कि कैसे हम देखते हैं एक हैश तालिका संरचना के साथ.
खैर, शब्द मौजूद है, तो यह हैश तालिका में पाया जा सकता है.
तो फिर आपको लगता है कि पता करने की कोशिश कर सकते हैं प्रासंगिक बाल्टी में शब्द.
>> तो जो बाल्टी कि शब्द में हो सकता है?
वैसे, अगर आप संख्या, कि सूचकांक मिलता था बाल्टी की, कि शब्द hashing द्वारा
और फिर उस लिंक की गई सूची में खोज, पूरे के माध्यम से traversing
स्ट्रिंग का उपयोग लिंक सूची, समारोह की तुलना करें.
>> लिंक की गई सूची के अंत है, तो जिसका अर्थ है, पहुंच गया है कि अपने कर्सर
अशक्त पहुंचता है, तो शब्द नहीं है शब्दकोश में पाया जा सकता.
यह किसी भी अन्य बाल्टी में नहीं होगा.
यहाँ तो, आप वहाँ कैसे हो सकता है देख सकते हैं या तो होने के बीच एक व्यापार बंद होना
क्रमबद्ध लिंक सूचियों या unsorted वाले.
या तो के दौरान अधिक समय लगेगा जांच के दौरान समय लोड या अधिक.
>> कैसे आप में जाँच हो सकता है एक Trie संरचना?
हम नीचे की ओर यात्रा करने के लिए जा रहे हैं Trie में.
Inputted शब्द में प्रत्येक अक्षर के लिए हम जाँच कर रहे हैं कि, हम उस के लिए जाना होगा
बच्चों में तत्व इसी.
>> उस तत्व रिक्त है, तो इसका मतलब है कि कोई substrings कर रहे हैं कि
हमारे इनपुट शब्द युक्त, ताकि शब्द गलत वर्तनी है.
यह रिक्त नहीं है, तो हम करने के लिए स्थानांतरित कर सकते हैं हम कर रहे हैं कि शब्द की अगली पत्र
इस प्रक्रिया की जाँच करें और जारी रखें हम अंत तक पहुँचने तक
इनपुट शब्द की.
और फिर हम जांच कर सकते हैं शब्द सच है.
यह तो बहुत अच्छा है.
शब्द सही है.
लेकिन अगर नहीं, कि भले ही substring Trie में मौजूद है, शब्द है
गलत वर्तनी.
>> समारोह साइज कहा जाता है, आकार शब्दों की संख्या वापस आ जाना चाहिए कि
आपके दिए गए शब्दकोश में हैं डेटा संरचना.
आप, आप एक हैश तालिका का उपयोग कर रहे हैं तो हर एक के माध्यम से जा सकते हैं या तो
हर एक में लिंक की गई सूची बाल्टी संख्या की गणना
शब्दों के होते हैं.
आप एक Trie का उपयोग कर रहे हैं, तो आप कर सकते हैं हर गैर बातिल के माध्यम से जाना
अपने Trie में पथ.
या फिर आप शब्दकोश लोड कर रहे हैं, जबकि में, हो सकता है आप कैसे का ट्रैक रख सकते हैं
आप अंदर लोड कर रहे हैं कई शब्द
>> Speller.c जाँच पूरी हो जाने के बाद शब्दकोश के खिलाफ पाठ फ़ाइल, तो
यह किया है और इसलिए यह अनलोड कहता है जहां अपने काम कुछ भी मुक्त करने के लिए है
आप malloced गया है.
आप तो, आप एक हैश तालिका का उपयोग करते हैं तो से बचने के लिए विशेष रूप से सावधान रहने की जरूरत
कुछ को मुक्त नहीं द्वारा स्मृति लीक समय से पहले और हर पकड़ा
आप नि: शुल्क पहले ही कड़ी.
>> तो हैश तालिका में प्रत्येक तत्व के लिए और लिंक की गई सूची में प्रत्येक नोड के लिए,
आप उस नोड मुक्त करने के लिए चाहता हूँ.
आप कैसे मुक्त कराने के बारे में जाना है एक लिंक की गई सूची?
अपने नोड सूचक कर्सर के लिए सेटिंग की शुरुआत करने के लिए सिर,
लिंक सूची, तब अपने कर्सर जबकि अशक्त नहीं है, आप एक अस्थायी सेट कर सकते हैं
अपने कर्सर को नोड सूचक.
तब कर्सर अग्रिम.
और फिर आपको लगता है कि अस्थायी मुक्त कर सकते हैं मूल्य जबकि अभी भी पर पकड़
बाद में सब कुछ.
>> क्या आप एक Trie प्रयोग कर रहे हैं?
तो फिर ऐसा करने के लिए सबसे अच्छा तरीका बहुत से अनलोड करने के लिए है
नीचे से ऊपर.
संभव सबसे कम करने के लिए उड़ान से नोड, आप सभी संकेत मुक्त कर सकते हैं
तो है कि बच्चों और पीछे ऊपर की ओर, सभी के सभी तत्वों को मुक्त
बच्चों सरणियों की, जब तक आप अपने शीर्ष रूट नोड मारा.
यहाँ है जहां Recursion काम में आ जाएगा.
>> सुनिश्चित करें कि आप शायद मुक्त कर दिया गया है कि बनाने के लिए आप malloced दिया है कि सब कुछ,
आप वेलग्रिंड उपयोग कर सकते हैं.
वेलग्रिंड रनिंग अपने कार्यक्रम चलेंगे स्मृति के कितने बाइट्स गिनती
आप का उपयोग और आप है कि यकीन कर रहे हैं आप कह रही है, उन सब को मुक्त कर दिया
तुम हो सकता है, जहां मुक्त करने के लिए भूल.
वेलग्रिंड आपको बताता है तो एक बार उस चलाने और और तुम तो, आगे बढ़ो देता है
आप उतारना खत्म कर दिया है.
>> अब, आप सुझावों की एक जोड़ी जाने से पहले बंद और लागू करने शुरू आपके
शब्दकोश.
मैं एक छोटे से पारित करने की सिफारिश था आप परीक्षण करने के लिए कोशिश कर रहे शब्दकोश जब
सकल घरेलू उत्पाद के साथ बातें बाहर और डिबगिंग.
स्पेलर का उपयोग होता है. / स्पेलर, एक वैकल्पिक शब्दकोश, और फिर एक पाठ.
>> डिफ़ॉल्ट रूप से, उस में लोड करता है बड़े शब्दकोश.
तो आप छोटे में पारित करने के लिए चाहते हो सकता है शब्दकोश, या शायद यह भी सुनिश्चित करें कि आपके
खुद, अनुरूपण अपने शब्दकोश और अपने पाठ फ़ाइल.
>> और फिर अंत में, मैं भी सुझा था एक कलम और कागज लेने के लिए और आकर्षित करने के लिए
चीजें बाहर से पहले, उसके दौरान और बाद आप अपने कोड के सभी लिखा है.
जरा सोचो कि तुम मिल गया है कि यह सुनिश्चित कर लें उन संकेत सिर्फ सही.
>> मैं तुम्हें शुभकामनाएँ.
और आप समाप्त करने के बाद आप चाहें तो बड़े बोर्ड और चुनौती देने के लिए
अपने कार्यक्रम की तुलना में है देखो कितनी तेजी अपने सहपाठियों, तो मैं प्रोत्साहित करते हैं
आपको लगता है कि बाहर की जाँच करने के लिए.
>> उस के साथ, आप खत्म कर दिया है स्पेलर PSet.
मेरा नाम Zamyla है, और इस CS50 है.