दैनिक प्रोग्रामिंग समस्याओं के लिए 11 सी++ कोड स्निपेट्स

सी ++ सबसे व्यापक रूप से उपयोग की जाने वाली प्रोग्रामिंग भाषाओं में से एक है। यह हर दिन लाखों प्रोग्रामर द्वारा उपयोग किया जाता है और प्रतिस्पर्धी प्रोग्रामिंग के लिए सबसे पसंदीदा भाषा है।

यहां, हम 11 C++ कोड स्निपेट सूचीबद्ध करेंगे जो आपकी दैनिक प्रोग्रामिंग समस्याओं में आपकी सहायता कर सकते हैं। तो, बिना किसी देरी के, चलिए शुरू करते हैं।

1. एक वेक्टर का आकार खोजें

आप का उपयोग करके वेक्टर का आकार पा सकते हैं आकार() समारोह।

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
वेक्टर <पूर्णांक> एआर 1 = {1, 2, 3, 4};
वेक्टर <पूर्णांक> एआर 2 = {};
वेक्टर <तैरना> arr3 = {1.2, 3.8, 3.0, 2.7, 6.6};
अदालत <<"एआर 1 का आकार: "<< arr1. आकार () << एंडल;
अदालत <<"एआर 2 का आकार: "<< arr2. आकार () << एंडल;
अदालत <<"एआर 3 का आकार: "<< arr3.आकार () << एंडल;
वापसी0;
}

आउटपुट:

गिरफ्तारी का आकार1: 4
एआर 2 का आकार: 0
एआर 3 का आकार: 5

2. एक सरणी शफ़ल करें

आप सी ++ में एक सरणी को शफल कर सकते हैं फेरबदल () समारोह।

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
वेक्टर 





instagram viewer

<पूर्णांक> गिरफ्तारी = {1, 2, 3, 4};
अहस्ताक्षरित बीज = 0;
अदालत <<"मूल सरणी:";
के लिए (पूर्णांक एली: गिरफ्तार)
{
अदालत << हाथी <<"";
}
अदालत << एंडल;
मिश्रण(आगमन।शुरू करना(), आगमन।अंत(), डिफ़ॉल्ट_यादृच्छिक_इंजन(बीज));
अदालत <<"फेरबदल सरणी:";
के लिए (पूर्णांक एली: गिरफ्तार)
{
अदालत << हाथी <<"";
}
वापसी0;
}

आउटपुट:

मूल सरणी:1234
फेरबदल सरणी:2314

3. C++. में दो चर स्वैप करें

आप बिल्ट-इन का उपयोग करके C++ में दो वेरिएबल को स्वैप कर सकते हैं बदलना() का कार्य सी ++ एसटीएल पुस्तकालय.

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
पूर्णांक एक्स = 5, वाई = 10;
 स्ट्रिंग str1 = "उपयोग करना", str2 = "मुओ";
 अदालत <<"स्वैपिंग से पहले: "<< एंडल;
 अदालत <<"एक्स: "<< एक्स << एंडल;
 अदालत <<"वाई: "<< आप << एंडल;
 अदालत <<"str1: "<< str1 << एंडल;
 अदालत <<"str2: "<< str2 << एंडल;
 स्वैप (एक्स, वाई);
 स्वैप (str1, str2);
 अदालत <<"अदला-बदली के बाद: "<< एंडल;
 अदालत <<"एक्स: "<< एक्स << एंडल;
 अदालत <<"वाई: "<< आप << एंडल;
 अदालत <<"str1: "<< str1 << एंडल;
 अदालत <<"str2: "<< str2 << एंडल;
वापसी0;
}

आउटपुट:

स्वैपिंग से पहले:
एक्स: 5
वाई: 10
str1: MakeUseOf
str2: MUO
अदला-बदली के बाद:
एक्स: 10
वाई: 5
str1: MUO
str2: MakeUseOf

4. किसी संख्या के अंकों का योग ज्ञात कीजिए

आप निम्न प्रक्रिया का उपयोग करके किसी संख्या के अंकों का योग ज्ञात कर सकते हैं:

• परिणाम को संग्रहीत करने के लिए एक योग चर प्रारंभ करें।
• 10 के साथ मापांक संक्रिया करके शेष संख्या ज्ञात कीजिए।
• शेष राशि को योग के साथ जोड़ें।
• संख्या को 10 से विभाजित करें।
• चरण 2 से प्रक्रिया को दोहराएं जबकि संख्या 10 से अधिक है।

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
पूर्णांक अंक =4635, योग =0, अस्थायी;
जबकि(संख्या!= 0)
{
अस्थायी = संख्या% 10;
योग = योग + अस्थायी;
अंक = संख्या/10;
}
अदालत <<"जोड़: "<< जोड़ << एंडल;
वापसी0;
}

आउटपुट:

योग: 18

5. एक वेक्टर को दूसरे वेक्टर में कॉपी करें

सी ++ में वेक्टर को दूसरे वेक्टर में कॉपी करने के कई तरीके हैं। आप असाइनमेंट ऑपरेटर का उपयोग कर सकते हैं या वेक्टर को कंस्ट्रक्टर के रूप में पास कर सकते हैं।

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
खालीपनप्रिंटवेक्टर(वेक्टर <पूर्णांक> वीईसी)
{
के लिए (ऑटो ele: vec)
{
अदालत << हाथी <<"";
}
अदालत << एंडल;
}
पूर्णांकमुख्य()
{
वेक्टर <पूर्णांक> वीईसी = {1, 2, 3, 4, 5};
प्रिंटवेक्टर (वीईसी);
// विधि 1: असाइनमेंट ऑपरेटर का उपयोग करना
वेक्टर <पूर्णांक> newVec1 = vec;
प्रिंटवेक्टर (newVec1);
// विधि 2: वेक्टर को कंस्ट्रक्टर के रूप में पास करके
वेक्टर <पूर्णांक> newVec2 (vec);
प्रिंटवेक्टर (newVec2);
वापसी0;
}

आउटपुट:

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

6. एक सरणी के अधिकतम और न्यूनतम तत्व खोजें

आप का उपयोग करके किसी सरणी से अधिकतम और न्यूनतम तत्व पा सकते हैं max_element () और min_element () कार्य, क्रमशः।

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
पूर्णांक गिरफ्तार [] = {23, 56, 87, 12, 56};
पूर्णांक आकार = आकार (गिरफ्तारी) / आकार (गिरफ्तारी [0]);
अदालत <<"अधिकतम तत्व: "<< *max_element (गिरफ्तारी, गिरफ्तारी + आकार) << एंडल;
अदालत <<"न्यूनतम तत्व: "<< *min_element (गिरफ्तारी, गिरफ्तारी + आकार) << एंडल;
वापसी0;
}

आउटपुट:

अधिकतम तत्व: 87
न्यूनतम तत्व: 12

7. एक सेट में तत्व सम्मिलित करें

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

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
सेट<डोरी> अनुसूचित जनजाति;
सेंट सम्मिलित करें ("बनाना");
सेंट सम्मिलित करें ("उपयोग");
सेंट सम्मिलित करें ("का");
सेंट सम्मिलित करें ("का");
के लिए (ऑटो इट = st.begin (); यह! = सेंट एंड (); यह ++)
{
अदालत << *यह <<"";
}
वापसी0;
}

आउटपुट:

का बनना उपयोग

8. स्ट्रिंग से डुप्लिकेट निकालें

आप निम्न विधि का उपयोग करके एक स्ट्रिंग से डुप्लिकेट वर्णों को हटा सकते हैं:

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
खालीपनडुप्लिकेट कैरेक्टर हटाएं(चारो स्ट्र [], पूर्णांक आकार)
{
पूर्णांक न्यूइंडेक्स =0;
// सभी पात्रों के माध्यम से ट्रैवर्सिंग
के लिए(पूर्णांक मैं =0; मैं {
पूर्णांक जे;
// पहले वर्ण से वर्तमान वर्ण तक ट्रैवर्सिंग लूप
 के लिए (जे = 0; जे<मैं; जे++)
 {
 अगर (str [i] == str [j])
 {
टूटना;
 }
 }
 अगर (जे == मैं)
 {
 str[newIndex++] = str[i];
 }
 }
// डुप्लिकेट को हटाने के बाद, हम बनाते हैं
// स्ट्रिंग का खाली हिस्सा शून्य करने के लिए
 स्ट्र [न्यूइंडेक्स] = '\0';
}
पूर्णांकमुख्य()
{
 चार str[] = "उपयोग करना";
पूर्णांक आकार = स्ट्रेल (str);
 अदालत <<"मूल स्ट्रिंग: "<< एंडल;
 अदालत << एसटीआर << एंडल;
 हटाएं डुप्लीकेट कैरेक्टर (str, आकार);
 अदालत <<"नई स्ट्रिंग: "<< एंडल;
 अदालत << एसटीआर << एंडल;
वापसी0;
}

आउटपुट:

मूल डोरी:
उपयोग करना
नया डोरी:
MakeUsOf

9. C++ स्ट्रिंग की लंबाई ज्ञात करें

आप a. की लंबाई पा सकते हैं सी++ स्ट्रिंग का उपयोग लंबाई() समारोह। वैकल्पिक रूप से, आप इसका उपयोग भी कर सकते हैं आकार() समारोह (यह का एक उपनाम है लंबाई() समारोह)।

 #शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
 स्ट्रिंग str1 = "उपयोग करना";
 अदालत <<"लंबाई की "<< str1 <<": "<< str1.लंबाई () << एंडल;
 स्ट्रिंग str2 = "लोरेम इप्सम";
 अदालत <<"लंबाई की "<< str2 <<": "<< str2.आकार () << एंडल;
वापसी0;
}

आउटपुट:

MakeUseOf की लंबाई: 9
लोरेम इप्सम की लंबाई: 11

10. ऐरे से एक तत्व हटाएं

आप निम्न दृष्टिकोण का उपयोग करके सरणी से किसी तत्व को हटा सकते हैं:

#शामिल करना<बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकDeleteElementFromArray(पूर्णांक गिरफ्तार [], पूर्णांक आकार, पूर्णांक एलिमेंट टू बी डिलीट किया गया)
{
पूर्णांक मैं, जे;
// खोजें कि क्या elementToBeDeleted मौजूद है
// सरणी में या नहीं
 के लिए (मैं = 0; मैं<आकार; मैं++)
 {
 अगर (गिरफ्तारी [i] == elementToBeDeleted)
 {
टूटना;
 }
 }
// यदि तत्व टोबीडेटेड सरणी में पाया जाता है
 अगर मैं < आकार)
 {
// हमें सरणी के आकार को कम करने की आवश्यकता है
// और बाकी तत्वों को शिफ्ट करें
 आकार = आकार - 1;
 के लिए (जे = मैं; जे<आकार; जे++)
 {
 एआर [जे] = एआर [जे + 1];
 }
 }
// नया सरणी आकार वापस आ गया है
वापसी आकार;
}
खालीपनप्रिंटअरेएलिमेंट्स(पूर्णांक गिरफ्तार [], पूर्णांक आकार)
{
के लिए(पूर्णांक मैं =0; मैं {
 अदालत << गिरफ्तार [मैं] <<"";
 }
 अदालत << एंडल;
}
पूर्णांकमुख्य()
{
पूर्णांक गिरफ्तार [] = {1, 2, 3, 4, 5};
पूर्णांक आकार = आकार (गिरफ्तारी) / आकार (गिरफ्तारी [0]);
 अदालत <<"मूल सरणी: "<< एंडल;
 PrintArrayElements (गिरफ्तारी, आकार);
पूर्णांक ElementToBeDeleted = 3;
 आकार = deleteElementFromArray (गिरफ्तारी, आकार, elementToBeDeleted);
 अदालत <<"नई सरणी: "<< एंडल;
 PrintArrayElements (गिरफ्तारी, आकार);
वापसी0;
}

आउटपुट:

मूल सरणी:
1 2 3 4 5
नयासरणी:
1 2 4 5 

कभी-कभी जटिल कोड को सीधे समझना आसान नहीं होता है। आपको इनमें से कुछ का पालन करना चाहिए बुनियादी प्रोग्रामिंग सिद्धांत जैसे आपके कोड को और अधिक मजबूत बनाने के लिए कोड का दस्तावेजीकरण करना, रिफैक्टरिंग करना आदि।

11. एक वेक्टर के माध्यम से पुनरावृति

आप एक वेक्टर के माध्यम से कई तरीकों से पुनरावृति कर सकते हैं। वेक्टर के माध्यम से पुनरावृति करने के तीन सबसे अधिक उपयोग किए जाने वाले तरीके नीचे दिए गए हैं:

के लिए रेंज का उपयोग करना

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
वेक्टर <पूर्णांक> वीईसी = {1, 2, 3, 4, 5};
// विधि 1: के लिए रेंज का उपयोग करना
के लिए (ऑटो तत्व: vec)
{
अदालत << तत्व <<"";
}
वापसी0;
}

अनुक्रमण का उपयोग करना

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
वेक्टर <पूर्णांक> वीईसी = {1, 2, 3, 4, 5};
// विधि 2: अनुक्रमण का उपयोग करना
के लिए(पूर्णांक मैं =0; मैं{
अदालत << वीईसी [मैं] <<"";
}
वापसी0;
}

इटरेटर के संदर्भ का उपयोग करना

#शामिल करना <बिट्स/एसटीडीसी++.एच>
का उपयोग करते हुए नाम स्थानकक्षा;
पूर्णांकमुख्य()
{
वेक्टर <पूर्णांक> वीईसी = {1, 2, 3, 4, 5};
// विधि 3: इटरेटर के संदर्भ का उपयोग करना
के लिए (ऑटो इट = शुरू करना(वीईसी); यह!= अंत(वीईसी); यह ++)
{
अदालत << *यह <<"";
}
वापसी0;
}

उपरोक्त तीन कोड समान आउटपुट प्रदर्शित करेंगे:

1 2 3 4 5

यदि आप इस लेख में उपयोग किए गए संपूर्ण स्रोत कोड को देखना चाहते हैं, तो यह है गिटहब भंडार.

C++ कोड स्निपेट्स का उपयोग करें

अपनी दैनिक प्रोग्रामिंग समस्याओं के लिए इन C++ कोड स्निपेट का उपयोग करें। चाहे आप साधारण प्रोग्राम लिखने के लिए या प्रतिस्पर्धी प्रोग्रामिंग के लिए C++ का उपयोग करें, ये कोड स्निपेट आपके काम आ सकते हैं।

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

गो के साथ शुरुआत करना

आगे पढ़िए

लेखक के बारे में