11 קטעי קוד C++ לבעיות תכנות יומיומיות

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

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

1. מצא את הגודל של וקטור

אתה יכול למצוא את הגודל של וקטור באמצעות ה גודל() פוּנקצִיָה.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
וֶקטוֹר <int> arr1 = {1, 2, 3, 4};
וֶקטוֹר <int> arr2 = {};
וֶקטוֹר <לָצוּף> arr3 = {1.2, 3.8, 3.0, 2.7, 6.6};
cout <<"גודל arr1: "<< arr1.size() << endl;
cout <<"גודל arr2: "<< arr2.size() << endl;
cout <<"גודל arr3: "<< arr3.size() << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

גודל arr1: 4
גודל arr2: 0
גודל arr3: 5

2. ערבב מערך

אתה יכול לערבב מערך ב-C++ באמצעות ה לְעַרְבֵּב() פוּנקצִיָה.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
וֶקטוֹר <int> arr = {1, 2, 3, 4};
זרע לא חתום = 0;
cout <<"מערך מקורי:";
ל (int ele: arr)
{
cout << ele <<"";
}
cout << endl;
לְעַרְבֵּב(arr.התחל(), arr.סוֹף(), default_random_engine(זֶרַע));
cout <<"מערך ערבב:";
ל (int ele: arr)
{
cout << ele <<"";
}
לַחֲזוֹר0;
}

תְפוּקָה:

מְקוֹרִי מַעֲרָך:1234
ערבב מַעֲרָך:2314

3. החלף שני משתנים ב-C++

אתה יכול להחליף שני משתנים ב-C++ באמצעות המובנה לְהַחלִיף() פונקציה של ספריית C++ STL.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
int x = 5, y = 10;
 מחרוזת str1 = "לעשות שימוש ב", str2 = "MUO";
 cout <<"לפני ההחלפה: "<< endl;
 cout <<"איקס: "<< איקס << endl;
 cout <<"y: "<< y << endl;
 cout <<"str1: "<< str1 << endl;
 cout <<"str2: "<< str2 << endl;
 החלפה (x, y);
 swap (str1, str2);
 cout <<"לאחר ההחלפה: "<< endl;
 cout <<"איקס: "<< איקס << endl;
 cout <<"y: "<< y << endl;
 cout <<"str1: "<< str1 << endl;
 cout <<"str2: "<< str2 << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

לפני ההחלפה:
x: 5
y: 10
str1: MakeUseOf
str2: MUO
לאחר ההחלפה:
x: 10
y: 5
str1: MUO
str2: MakeUseOf

4. מצא את סכום הספרות של מספר

אתה יכול למצוא את סכום הספרות של מספר באמצעות התהליך הבא:

• אתחול משתנה סכום כדי לאחסן את התוצאה.
• מצא את יתרת המספר על ידי ביצוע פעולת המודולוס עם 10.
• הוסף את השארית עם הסכום.
• מחלקים את המספר ב-10.
• חזור על התהליך משלב 2 כאשר המספר גדול מ-10.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
int מספר=4635, סכום=0, טמפ';
בזמן(מספר != 0)
{
temp = num%10;
sum = sum+temp;
num = num/10;
}
cout <<"סְכוּם: "<< סְכוּם << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

סכום: 18

5. העתק וקטור לוקטור אחר

ישנן מספר דרכים להעתיק וקטור לוקטור אחר ב-C++. אתה יכול להשתמש באופרטור ההקצאה או להעביר את הווקטור בתור בנאי כדי לעשות את אותו הדבר.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
בָּטֵלהדפס וקטור(וקטור <int> vec)
{
עבור (אוטו ele: vec)
{
cout << ele <<"";
}
cout << endl;
}
intרָאשִׁי()
{
וֶקטוֹר <int> vec = {1, 2, 3, 4, 5};
printVector (vec);
// שיטה 1: שימוש ב-Assignment Operator
וֶקטוֹר <int> newVec1 = vec;
printVector (newVec1);
// שיטה 2: על ידי העברת וקטור בתור בנאי
וֶקטוֹר <int> newVec2(vec);
printVector (newVec2);
לַחֲזוֹר0;
}

תְפוּקָה:

1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

6. מצא את הרכיבים המקסימליים והמינימליים של מערך

אתה יכול למצוא את הרכיבים המקסימליים והמינימליים ממערך באמצעות ה- max_element() ו min_element() פונקציות, בהתאמה.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
int arr[] = {23, 56, 87, 12, 56};
int size = sizeof (arr)/sizeof (arr[0]);
cout <<"אלמנט מקסימלי: "<< *max_element (arr, arr+size) << endl;
cout <<"אלמנט מינימלי: "<< *min_element (arr, arr+size) << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

רכיב מקסימלי: 87
אלמנט מינימלי: 12

7. הוסף אלמנטים בסט

אתה יכול להכניס אלמנטים לקבוצה באמצעות ה- לְהַכנִיס() פוּנקצִיָה. פונקציה זו מקבלת את האלמנט כפרמטר שיוכנס לסט.

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
מַעֲרֶכֶת<חוּט> רחוב;
st.insert("עשה");
st.insert("להשתמש");
st.insert("שֶׁל");
st.insert("שֶׁל");
for (auto it = st.begin(); it != st.end(); זה++)
{
cout << *זה <<"";
}
לַחֲזוֹר0;
}

תְפוּקָה:

לִהַבִין להשתמש

8. הסר כפיל ממחרוזת

אתה יכול להסיר את התווים הכפולים ממחרוזת בשיטה הבאה:

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
בָּטֵלהסר תווים כפולים(לְהַשְׁחִיר str[], int גודל)
{
int newIndex=0;
// מעבר בין כל הדמויות
ל(int i=0; אני {
int י;
// מעבר לולאה מהתו הראשון לדמות הנוכחית
 עבור (j=0; י<אני; j++)
 {
 if (str[i]==str[j])
 {
לשבור;
 }
 }
 אם (j == i)
 {
 str[newIndex++] = str[i];
 }
 }
// לאחר הסרת כפילויות, אנחנו עושים
// החלק הפנוי של המחרוזת ל-null
 str[newIndex] = '\0';
}
intרָאשִׁי()
{
 char str[] = "לעשות שימוש ב";
int גודל = strlen (str);
 cout <<"מחרוזת מקורית: "<< endl;
 cout << str << endl;
 removeDuplicateCharacters (str, גודל);
 cout <<"מחרוזת חדשה: "<< endl;
 cout << str << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

מְקוֹרִי חוּט:
לעשות שימוש ב
חָדָשׁ חוּט:
MakeUsOf

9. מצא את האורך של מחרוזת C++

אתה יכול למצוא את האורך של א מחרוזת C++ משתמש ב אורך() פוּנקצִיָה. לחלופין, אתה יכול גם להשתמש ב- גודל() פונקציה (זה כינוי של ה אורך() פוּנקצִיָה).

 #לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
 מחרוזת str1 = "לעשות שימוש ב";
 cout <<"אורך של "<< str1 <<": "<< str1.length() << endl;
 מחרוזת str2 = "lorem ipsum";
 cout <<"אורך של "<< str2 <<": "<< str2.size() << endl;
לַחֲזוֹר0;
}

תְפוּקָה:

אורך MakeUseOf: 9
אורך lorem ipsum: 11

10. מחק אלמנט מהמערך

ניתן למחוק אלמנט מהמערך באמצעות הגישה הבאה:

#לִכלוֹל<bits/stdc++.h>
באמצעות מרחב שמותסטד;
intdeleteElementFromArray(int arr[], int גודל, int elementToBeDeleted)
{
int אני, י;
// חפש אם elementToBeDeleted קיים
// במערך או לא
 עבור (i=0; אני<גודל; i++)
 {
 if (arr[i] == elementToBeDeleted)
 {
לשבור;
 }
 }
// אם elementToBeDeleted נמצא במערך
 אם אני < גודל)
 {
// עלינו להקטין את גודל המערך
// והסט את שאר האלמנטים
 גודל = מידה - 1;
 עבור (j=i; י<גודל; j++)
 {
 arr[j] = arr[j+1];
 }
 }
// גודל מערך חדש מוחזר
לַחֲזוֹר גודל;
}
בָּטֵלprintArrayElements(int arr[], int גודל)
{
ל(int i=0; אני {
 cout << arr[i] <<"";
 }
 cout << endl;
}
intרָאשִׁי()
{
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof (arr)/sizeof (arr[0]);
 cout <<"מערך מקורי: "<< endl;
 printArrayElements (arr, size);
int elementToBeDeleted = 3;
 size = deleteElementFromArray (arr, size, elementToBeDeleted);
 cout <<"מערך חדש: "<< endl;
 printArrayElements (arr, size);
לַחֲזוֹר0;
}

תְפוּקָה:

מְקוֹרִי מַעֲרָך:
1 2 3 4 5
חָדָשׁמַעֲרָך:
1 2 4 5 

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

11. איטרציה דרך וקטור

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

שימוש בטווח עבור

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
וֶקטוֹר <int> vec = {1, 2, 3, 4, 5};
// שיטה 1: שימוש בטווח עבור
עבור (אלמנט אוטומטי: vec)
{
cout << אֵלֵמֶנט <<"";
}
לַחֲזוֹר0;
}

שימוש באינדקס

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
וֶקטוֹר <int> vec = {1, 2, 3, 4, 5};
// שיטה 2: שימוש באינדקס
ל(int i=0; אני{
cout << vec[i] <<"";
}
לַחֲזוֹר0;
}

שימוש בהפניה של האיטרטור

#לִכלוֹל <bits/stdc++.h>
באמצעות מרחב שמותסטד;
intרָאשִׁי()
{
וֶקטוֹר <int> vec = {1, 2, 3, 4, 5};
// שיטה 3: שימוש בהפניה של האיטרטור
עבור (auto it = התחל(vec); זה != סוֹף(vec); זה++)
{
cout << *זה <<"";
}
לַחֲזוֹר0;
}

שלושת הקודים לעיל יציגו את אותו פלט:

1 2 3 4 5

אם אתה רוצה לעיין בקוד המקור המלא המשמש במאמר זה, הנה מאגר GitHub.

השתמש ב-C++ Code Snippets

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

לחלופין, כדאי שתתחיל לעבוד עם Go אם אתה רוצה לנסות את הידיים שלך עם רובוטיקה, DevOps, תכנות בענן, מדע נתונים או בינה מלאכותית. Go היא שפת תכנות בקוד פתוח, קלה ללמידה, עם מספר יתרונות על פני שפות תכנות אחרות.

תחילת העבודה עם Go

קרא הבא

על הסופר