Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ में पैरेंथेसिस जोड़ने के विभिन्न तरीके (Different Ways to Add Parentheses)

मान लीजिए हमारे पास संख्याओं और ऑपरेटरों (+, -, *) की एक स्ट्रिंग है। हमें सभी संभावित परिणाम ढूंढने हैं जो संख्याओं और ऑपरेटरों को अलग-अलग तरीकों से ग्रुप करके प्राप्त होते हैं। उदाहरण के लिए, इनपुट "2*3-4*5" के लिए आउटपुट [-34, -14, -10, -10, 10] होगा, क्योंकि:

  • (2*(3-(4*5))) = -34
  • ((2*3)-(4*5)) = -14
  • ((2*(3-4))*5) = -10
  • (2*((3-4)*5)) = -10
  • (((2*3)-4)*5) = 10

हल करने के चरण

  1. मेमोइजेशन के लिए एक मैप memo परिभाषित करें।
  2. एक रिकर्सिव फ़ंक्शन solve() बनाएं जो इनपुट स्ट्रिंग लेता है।
  3. एक सरणी ret बनाएं परिणाम स्टोर करने के लिए।
  4. यदि इनपुट memo में पहले से मौजूद है, तो उसे लौटाएं।
  5. स्ट्रिंग के प्रत्येक वर्ण के लिए लूप चलाएं।
  6. यदि वर्ण एक ऑपरेटर (+, -, *) है, तो:
    • बाएं भाग के लिए रिकर्सिव कॉल करें: part1 = solve(input.substr(0, i))
    • दाएं भाग के लिए रिकर्सिव कॉल करें: part2 = solve(input.substr(i+1))
    • दोनों भागों के सभी संयोजनों के लिए ऑपरेशन करें और ret में जोड़ें।
  7. यदि ret खाली है (यानी कोई ऑपरेटर नहीं मिला), तो स्ट्रिंग को पूर्णांक में बदलकर लौटाएं।
  8. memo[input] = ret स्टोर करें और लौटाएं।

C++ उदाहरण

#include <bits/stdc++.h>
using namespace std;

void print_vector(vector<int> v) {
    cout << "[";
    for (int i = 0; i < v.size(); i++) {
        cout << v[i] << ", ";
    }
    cout << "]" << endl;
}

class Solution {
public:
    map<string, vector<int>> memo;
    vector<int> diffWaysToCompute(string input) {
        vector<int> ret;
        if (memo.count(input)) return memo[input];
        for (int i = 0; i < input.size(); i++) {
            if (input[i] == '+' || input[i] == '*' || input[i] == '-') {
                vector<int> part1 = diffWaysToCompute(input.substr(0, i));
                vector<int> part2 = diffWaysToCompute(input.substr(i + 1));
                for (int j = 0; j < part1.size(); j++) {
                    for (int k = 0; k < part2.size(); k++) {
                        if (input[i] == '+')
                            ret.push_back(part1[j] + part2[k]);
                        else if (input[i] == '*')
                            ret.push_back(part1[j] * part2[k]);
                        else
                            ret.push_back(part1[j] - part2[k]);
                    }
                }
            }
        }
        if (ret.empty())
            ret.push_back(stoi(input));
        return memo[input] = ret;
    }
};

int main() {
    Solution ob;
    print_vector(ob.diffWaysToCompute("2*3-4*5"));
    return 0;
}

इनपुट

"2*3-4*5"

आउटपुट

[-34, -10, -14, -10, 10]
  1. - C++ में स्ट्रिंग में बोल्ड टैग जोड़ें

    मान लीजिए हमारे पास एक स्ट्रिंग s और स्ट्रिंग्स की एक सूची dict है, हमें s में उन उपस्ट्रिंग्स को लपेटने के लिए बोल्ड टैग और का एक बंद युग्म जोड़ना होगा जो dict में मौजूद हैं। जब दो ऐसी उपस्ट्रिंग्स ओवरलैप होती हैं, तो हमें उन्हें केवल एक युग्म बोल्ड टैग से एक साथ लपेटना होगा। इसके अलावा, यदि बोल

  1. - C++ में दो अलग-अलग सेट्स से एक या अधिक जोड़े चुनने के तरीके

    इस समस्या में, हमें दो पॉजिटिव संख्याएं n और m (n <= m) दी गई हैं जो क्रमशः दो सेट्स के कुल आइटम्स की संख्या हैं। हमारा कार्य इन सेट्स के आइटम्स से जोड़े (एक या अधिक) चुनने के कुल तरीकों की संख्या ज्ञात करना है। उदाहरण इनपुट 2 2 आउटपुट 6 व्याख्या हमारे पास दो सेट्स हैं दोनों में दो एलिमेंट्स हैं Set

  1. C++ में टू सम IV - इनपुट एक BST है C++ में टू सम IV - इनपुट एक BST है

    मान लीजिए हमारे पास एक बाइनरी सर्च ट्री और एक लक्ष्य मान है; हमें जांचना है कि क्या BST में दो तत्व मौजूद हैं जिनका योग दिए गए लक्ष्य के बराबर है या नहीं। इसलिए, यदि इनपुट जैसा है: तो आउटपुट True होगा। इसे हल करने के लिए, हम निम्नलिखित चरणों का पालन करेंगे: एक सरणी v परिभाषित करें एक फ़ंक्शन inor