להבות באמצעות C ++: 8 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

שלום חברים, כולנו מכירים את משחק הלהבות. חחח, זה אחד המשחקים הכי מצחיקים שעשו את הילדות שלנו מאושרת יותר. במדריך זה, אנו הולכים לראות כיצד לקודד תוכנית להבות באמצעות שפת C ++.

שלב 1: מושגים בשימוש

כאן השתמשתי ברשימה המקושרת כפולת החוזר.

שלב 2: הפונקציה העיקרית

int main ()

{

שם מחרוזת 1, שם 2;

int n1, n2; cout << "הזן שם ראשון:"; getline (cin, name1); cout << "הזן שם שני:"; getline (cin, name2);

}

ראשית, עלינו לקבל את שני השמות עם רווח אז אני משתמש בפונקציה getline () כדי לקבל את המחרוזת עם רווח.

שלב 3: כיצד להשמיט תווים מיוחדים?

emit emit (string & a)

{

עבור (int i = 0; a ! = '\ 0'; i ++)

{

אם (a > = 'a' && a <= 'z') {}

אחרת אם (a > = 'A' && a <= 'Z') {}

אַחֵר

a = '0';

}

}

כעת, עלינו להסיר את התווים המיוחדים כמו &, $, '' … וכו '. באמצעות פונקציה זו הסרנו את כל התווים מלבד האלפבית. כאן, במקום להסיר, אני מחליף אותו ב- '0'.

שלב 4: הסרת אותן תווים

עבור (i = 0; שם 1 ! = '\ 0'; i ++)

עבור (j = 0; name2 [j]! = '\ 0'; j ++)

אם ((שם 1 == שם 2 [j] || שם 1 == שם 2 [j] +32))

{

name1 = '0';

name2 [j] = '0';

לשבור;

}

זהו השלב הראשון של משחק הלהבות, שעלינו להסיר את אותן הדמויות המופיעות בשני השמות. קטע קוד זה עוזר לנו להחליף את אותן התווים ב- '0' והוא גם עובד היטב אפילו שהוא מכיל גם רישיות וגם קטנות. הצהרת ההפסקה מסייעת לנו להימנע מהסרה של דמויות חוזרות.

j = 0; עבור (i = 0; שם 1 ! = '\ 0'; i ++)

אם (name1 ! = '0')

j ++;

עבור (i = 0; name2 ! = '\ 0'; i ++)

אם (name2 ! = '0')

j ++;

if (j == 0) cout << "NO FLAMES";

כאן, אנו מסירים את כל ה -0 שיש בשני השמות. לכן, לבסוף, בכל זאת, תווים מוסרים. ואז ה- j מצטמצם שזהו ספירת האותיות הקיימות בשני השמות לאחר הסרת אותן תווים. כעת עלינו לבדוק האם הוא מכיל תו אחד לפחות או לא. כדי להפוך את הקוד ליעיל עלינו לומר שאין אפשרות לשחק את משחק הלהבות אם הוא אינו מכיל תווים ייחודיים.

שלב 5: יצירת רשימה מעגלית כפולה

string a = "להבות";

ראשית, צור מחרוזת גלובלית המכילה "להבות".

צומת struct typedef {

נתוני צ'ארה;

צומת *הבא, *prev;

}צוֹמֶת;

צומת *למעלה = NULL, *טמפ ';

כעת, צור מבנה המכיל נתוני תווים, מצביע הכתובות הבא ומצביע הכתובות הקודם.

לאחר מכן צור מצביע המצביע על החלק העליון של הרשימה המקושרת.

node* ins (char a) {

צומת *new1;

new1 = צומת חדש;

new1-> data = a;

new1-> next = NULL;

new1-> prev = NULL;

אם (למעלה == NULL)

{

למעלה = חדש 1;

טמפ '= למעלה;

}

אַחֵר

{

temp-> next = new1;

new1-> prev = temp;

טמפ '= new1;

}

החזרה למעלה;

}

לאחר מכן, הכנס את מחרוזת ה"להבות "לרשימה המקושרת כפול לפי התווים.

בדיקת ריק (int j) {

int count1, flag = 0;

עבור (int i = 0; a ! = '\ 0'; i ++)

top = ins (a );

}

שלב 6: קוד למשחק הלהבות

בדיקת ריק (int j)

{

int count1, flag = 0;

עבור (int i = 0; a ! = '\ 0'; i ++)

top = ins (a );

צומת *cur = top, *prev1;

temp-> next = top;

למעלה-> prev = temp;

בעוד (1)

{

count1 = 1;

בעוד (count1 <j)

{

cur = cur-> הבא;

count1 ++;

}

צומת *temp1 = cur;

prev1 = cur-> prev;

cur-> prev-> next = cur-> next;

cur-> next-> prev = cur-> prev;

temp1-> next = NULL;

חינם (temp1);

cur = prev1-> הבא;

צומת *test = cur;

if (test-> data == test-> next-> data)

לשבור;

}

}

עלינו להריץ את הרשימה המעגלית שהיא מחרוזת ה"להבות "בהתאם למספר הדמויות הייחודיות. לאחר מכן עלינו להסיר את הדמות ב"להבות "החופפות לספירה. עלינו להבין את השימוש ברשימה המקושרת כפול בקטע קוד זה. זה עוזר מאוד להסיר דמות מסוימת. זה מסיר ברציפות. עד שהוא מגיע למצב שאותן דמויות מגיעות שוב ושוב.

אם (test-> data == test-> next-> data) שבירה;

שלב 7: ספר את התוצאה

switch (cur-> data)

{

מקרה 'f': cout << "חברים &&";

לשבור;

מקרה 'l': cout << "LOVE <3";

לשבור;

מקרה 'a': cout << "AFFECTION $";

לשבור;

case 'm': cout << "נישואין:)";

לשבור;

מקרה 'e': cout << "אויב:(";

לשבור;

case 's': cout << "SIBLING";

לשבור; }

השתמש בהצהרת מתג זו כדי לספר את התוצאה הסופית שהיא התו האחרון שנותר לאחר הסרת כל התווים האחרים בהתאם לספירה.

עכשיו אתה יכול להפעיל להבות בקלות על ידי הזנת השמות, זה מצחיק נכון. שחק את המשחק הזה באמצעות שמות החבר שלך ועשה אותו כועס LOL. תודה.

שלב 8: קוד להבות

הקוד המלא של FLAMES זמין כאן, github.com/naveeen684/Flames-code-using-C-/tree/master