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

दिए गए अंक सेट से N तक की संख्याएं C++ में

मान लीजिए हमारे पास अंकों का एक सॉर्टेड सेट D है, जो {'1','2','3','4','5','6','7','8','9'} का एक गैर-खाली उपसमुच्चय है (0 को छोड़कर)। अब, हम इन अंकों का उपयोग करके कुछ संख्याएं लिखेंगे, प्रत्येक अंक का जितनी बार चाहें उतनी बार उपयोग कर सकते हैं। हमें उन धनात्मक पूर्णांकों की संख्या ढूंढनी है जो लिखे जा सकते हैं और N से कम या बराबर हैं।

उदाहरण के लिए, यदि D = [2,3,4,7], N = 100, तो आउटपुट 20 होगा।

हल करने का दृष्टिकोण

हम N से कम अंकों वाली संख्याओं को गिनते हैं, फिर समान अंकों वाली संख्याओं को अंक-दर-अंक गिनते हैं:

  • N को स्ट्रिंग में बदलें

  • N से कम अंकों वाली सभी संख्याओं को गिनें: sum(|D|^i)

  • समान अंकों की लंबाई के लिए, प्रत्येक स्थिति के लिए N के अंक से कम अंकों को गिनें

  • यदि N का वर्तमान अंक D में है, तो अगली स्थिति पर जारी रखें

  • अन्यथा, जल्दी वापस करें

  • यदि सभी अंक मेल खाते हैं, तो N के लिए 1 जोड़ें

उदाहरण

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

class Solution { 
public: 
    int atMostNGivenDigitSet(vector<string> &D, int N) { 
        string n = to_string(N); 
        int sz = n.size(); 
        int ret = 0; 
        
        for (int i = 1; i < sz; i++) { 
            ret += pow(D.size(), i); 
        } 
        
        for (int i = 0; i < sz; i++) { 
            bool hasSameNum = false; 
            for (string &x : D) { 
                if (x[0] < n[i]) { 
                    ret += pow(D.size(), sz - i - 1); 
                } else if (x[0] == n[i]) { 
                    hasSameNum = true; 
                } 
            } 
            if (!hasSameNum) return ret; 
        } 
        return ret + 1; 
    } 
}; 

int main(){ 
    Solution ob; 
    vector<string> v = {"2","3","4","7"}; 
    cout << (ob.atMostNGivenDigitSet(v, 100)); 
    return 0;
}

इनपुट

{"2","3","4","7"}, 100

आउटपुट

20
  1. C++ में दी गई शर्तों के साथ ग्रिड में 8 संख्याएं भरें C++ में दी गई शर्तों के साथ ग्रिड में 8 संख्याएं भरें

    समस्या विवरण हम 1, 2, 3, 4, 5, 6, 7, 8 को दिए गए चित्र में आठ वृत्तों में इस तरह रखना चाहते हैं कि कोई भी संख्या उस संख्या से सटी न हो जो अनुक्रम में उसके बगल में है। इनपुट ग्रिड 0-1-10 -1-1-1-1 0-1-10 आउटपुट एल्गोरिदम चरण N := 3, M := 4 NOTCONSIDERED := -1 फ़ंक्शन present_in_grid(grid, num

  1. - C++ प्रोग्राम: दिए गए प्रतिबंधों के तहत डुप्लिकेट ज्ञात करना

    मान लें हमारे पास 6 अलग-अलग संख्याओं की एक सूची है। केवल एक संख्या पांच बार दोहराई जाती है। इसलिए सरणी में कुल 10 तत्व हैं। केवल दो तुलनाओं का उपयोग करके डुप्लिकेट संख्या ज्ञात करें। यदि सूची [1, 2, 3, 4, 4, 4, 4, 4, 5, 6] की तरह है, तो आउटपुट 4 है। चूंकि केवल 10 संख्याएं हैं, तो किसी भी प्रकार की

  1. - C++ प्रोग्राम: दिए गए सेट के सभी विशिष्ट उपसमुच्चय (subsets) ज्ञात करना

    यहां हम देखेंगे कि दिए गए सेट के सभी विशिष्ट उपसमुच्चय कैसे प्रदर्शित करें। इसलिए यदि सेट {1, 2, 3} है, तो उपसमुच्चय होंगे {}, {1}, {2}, {3}, {1, 2}, {2, 3}, {1, 3}, {1, 2, 3}। सभी उपसमुच्चयों के सेट को पावर सेट (power set) कहा जाता है। पावर सेट में 2n तत्व होते हैं। हम 0 से 2n (बहिष्कृत) तक लूप कर