C++ का उपयोग करते हुए लपटें: 8 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

नमस्कार दोस्तों, आग की लपटों के खेल के बारे में हम सभी जानते हैं। लॉल, यह सबसे मजेदार खेलों में से एक है जिसने हमारे बचपन को और अधिक खुशहाल बना दिया है। इस निर्देश में, हम यह देखने जा रहे हैं कि C ++ भाषा का उपयोग करके फ्लेम प्रोग्राम को कैसे कोडित किया जाए।

चरण 1: प्रयुक्त अवधारणाएं

यहां मैंने सर्कुलर डबल लिंक्ड लिस्ट का इस्तेमाल किया।

चरण 2: मुख्य कार्य

मुख्य प्रवेश बिंदु()

{

स्ट्रिंग नाम 1, नाम 2;

इंट n1, n2; cout<<"प्रथम नाम दर्ज करें:"; गेटलाइन (सीन, नाम 1); cout<<"दूसरा नाम दर्ज करें:"; गेटलाइन (सीन, नाम 2);

}

सबसे पहले, हमें स्पेस के साथ दो नाम प्राप्त करने की आवश्यकता है, इसलिए मैं स्पेस के साथ स्ट्रिंग प्राप्त करने के लिए गेटलाइन () फ़ंक्शन का उपयोग करता हूं।

चरण 3: विशेष वर्णों को कैसे छोड़ें?

शून्य उत्सर्जन (स्ट्रिंग और ए)

{

for(int i=0;a!='\0';i++)

{

अगर (ए > = 'ए' और& ए <= 'जेड') {}

और अगर (a>='A'&&a<='Z'){}

अन्यथा

ए = '0';

}

}

अब, हमें &, $, '' … आदि जैसे विशेष वर्णों को हटाने की आवश्यकता है। इस फ़ंक्शन का उपयोग करके हमने अक्षर के अलावा अन्य सभी वर्णों को हटा दिया। यहां, मैं इसे हटाने के बजाय '0' से बदल देता हूं।

चरण 4: समान वर्ण हटाना

for(i=0;name1!='\0';i++)

for(j=0;name2[j]!='\0';j++)

अगर ((नाम १ == नाम २ [जे] || नाम १ == नाम २ [जे] +३२))

{

नाम 1 = '0';

नाम 2 [जे] = '0';

टूटना;

}

यह आग की लपटों के खेल का पहला चरण है, कि हमें उन्हीं पात्रों को हटाना होगा जो दो नामों में मौजूद हैं। यह कोड स्निपेट हमें समान वर्णों को '0' से बदलने में मदद करता है और यह भी अच्छी तरह से काम करता है यहां तक कि इसमें अपरकेस और लोअर केस दोनों शामिल हैं। ब्रेक स्टेटमेंट हमें दोहराए जाने वाले पात्रों को हटाने से बचने में मदद करता है।

j=0;के लिए(i=0;name1!='\0';i++)

अगर (नाम 1 ! = '0')

जे++;

for(i=0;name2!='\0';i++)

अगर (नाम २ ! = '0')

जे++;

अगर (जे == 0) कोउट << "नो फ्लेम्स";

यहां, हम उन सभी '0' को हटा देते हैं जो दोनों नामों में मौजूद हैं। इसलिए, अंत में, सभी समान, वर्ण हटा दिए जाते हैं। फिर j को बढ़ा दिया जाता है कि यह उन अक्षरों की गिनती है जो समान वर्णों को हटाने के बाद दोनों नामों में मौजूद हैं। अब हमें यह जांचने की आवश्यकता है कि इसमें कम से कम एक वर्ण है या नहीं। कोड को कुशल बनाने के लिए हमें यह बताने की जरूरत है कि लपटों के खेल को खेलने की कोई संभावना नहीं है यदि इसमें कोई अद्वितीय वर्ण नहीं है।

चरण 5: सर्कुलर डबल लिंक्ड लिस्ट बनाना

स्ट्रिंग ए = "लपटें";

सबसे पहले, एक वैश्विक स्ट्रिंग बनाएं जिसमें "लपटें" हों।

टाइपपीफ स्ट्रक्चर नोड {

चार डेटा;

नोड * अगला, * पिछला;

}नोड;

नोड * शीर्ष = नल, * अस्थायी;

अब, एक संरचना बनाएं जिसमें एक वर्ण डेटा, अगला पता सूचक और पिछला पता सूचक हो।

फिर एक पॉइंटर बनाएं जो लिंक की गई सूची के शीर्ष की ओर इशारा करता है।

नोड * इन्स (चार ए) {

नोड * नया 1;

नया 1 = नया नोड;

नया 1-> डेटा = ए;

नया 1-> अगला = नल;

नया1->पिछला=नल;

अगर (शीर्ष == नल)

{

शीर्ष = नया 1;

अस्थायी = शीर्ष;

}

अन्यथा

{

अस्थायी-> अगला = नया 1;

नया 1-> पिछला = अस्थायी;

अस्थायी = नया 1;

}

शीर्ष पर लौटें;

}

फिर, "लौ" स्ट्रिंग को चरित्र के अनुसार दोगुनी लिंक की गई सूची में डालें।

शून्य जांच (इंट जे) {

इंट काउंट 1, फ्लैग = 0;

for(int i=0;a!='\0';i++)

शीर्ष = इन्स (ए );

}

चरण 6: आग की लपटों को चलाने के लिए कोड

शून्य जांच (इंट जे)

{

इंट काउंट 1, फ्लैग = 0;

for(int i=0;a!='\0';i++)

शीर्ष = इन्स (ए );

नोड *cur=top, *prev1;

अस्थायी-> अगला = शीर्ष;

शीर्ष-> पिछला = अस्थायी;

जबकि(1)

{

गिनती1=1;

जबकि (गिनती 1 <जे)

{

वक्र = वक्र-> अगला;

गिनती1++;

}

नोड * अस्थायी 1 = वक्र;

पिछला1=cur->पिछला;

वक्र-> पिछला-> अगला = वक्र-> अगला;

वक्र-> अगला-> पिछला = वक्र-> पिछला;

temp1-> अगला = नल;

मुक्त (अस्थायी 1);

cur=prev1->अगला;

नोड * परीक्षण = वक्र;

अगर (परीक्षण-> डेटा == परीक्षण-> अगला-> डेटा)

टूटना;

}

}

हमें वृत्ताकार सूची चलाने की आवश्यकता है जो अद्वितीय वर्णों की संख्या के अनुसार "लपटें" स्ट्रिंग है। फिर हमें "लौ" में चरित्र को हटाने की जरूरत है जो गिनती के साथ मेल खाता है। हमें इस कोड स्निपेट में एक डबल लिंक्ड लिस्ट के उपयोग का एहसास होना चाहिए। यह किसी विशेष चरित्र को हटाने में बहुत मदद करता है। यह लगातार हटाता है। जब तक यह स्थिति न आ जाए कि वही पात्र बार-बार आते हैं।

अगर (टेस्ट-> डेटा == टेस्ट-> अगला-> डेटा) ब्रेक;

चरण 7: परिणाम बताएं

स्विच (cur-> डेटा)

{

मामला 'f':cout<<"दोस्तों&&";

टूटना;

मामला 'एल': cout<<"प्यार<3";

टूटना;

मामला 'ए': cout<<"भाव $";

टूटना;

मामला 'एम': cout << "विवाह:)";

टूटना;

मामला 'ई': cout << "दुश्मन:(";

टूटना;

केस 'एस': कोउट << "सिब्लिंग";

टूटना; }

अंतिम परिणाम बताने के लिए इस स्विच स्टेटमेंट का उपयोग करें कि गिनती के अनुसार अन्य सभी वर्णों को हटाने के बाद अंतिम वर्ण शेष रहता है।

अब आप केवल नाम दर्ज करके आग की लपटों को आसानी से खेल सकते हैं, यह सही है। अपने दोस्तों के नाम का इस्तेमाल करके इस गेम को खेलें और उन्हें गुस्सा दिलाएं। धन्यवाद।

चरण 8: आग की लपटों के लिए कोड

फ्लेम्स का पूरा कोड यहां उपलब्ध है, github.com/naveeen684/Flames-code-using-C-/tree/master