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

C++ में कन्फ्यूजिंग नंबर II

मान लीजिए हमारे पास एक अंक है, अब यदि हम उस अंक को 180 डिग्री घुमाकर नए अंक बनाते हैं। जब 0, 1, 6, 8, 9 को 180 डिग्री घुमाया जाता है, तो वे क्रमशः 0, 1, 9, 8, 6 बन जाते हैं। लेकिन जब 2, 3, 4, 5 और 7 को 180 डिग्री घुमाया जाता है, तो वे अमान्य हो जाते हैं।

एक कन्फ्यूजिंग नंबर वह संख्या है जो 180 डिग्री घुमाने पर एक नई संख्या बन जाती है। तो, यदि हमारे पास एक पॉजिटिव इंटीजर N है, तो हमें 1 और N के बीच (सम्मिलित) कन्फ्यूजिंग नंबर्स की संख्या ज्ञात करनी है।

तो, यदि इनपुट 20 है, तो आउटपुट 6 होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे:

  • एक मैप mapping परिभाषित करें

  • एक ऐरे valid परिभाषित करें

  • एक फ़ंक्शन solve() परिभाषित करें, जो num, rotate, digit, N लेगा,

  • यदि rotate, num के बराबर नहीं है, तो:

    • (ret को 1 से बढ़ाएं)

  • i := 0 से शुरू करें, जब i < valid का आकार, अपडेट करें (i को 1 से बढ़ाएं), करें:

    • dig := valid[i]

    • यदि num * 10 + dig > N, तो:

      • लूप से बाहर आएं

    • solve(num * 10 + dig, mapping[dig] * digit + rotate, digit * 10, N)

  • मुख्य मेथड से निम्नलिखित करें:

  • ret := 0

  • valid := { 0, 1, 6, 8, 9 }

  • mapping[0] := 0

  • mapping[1] := 1

  • mapping[6] := 9

  • mapping[9] := 6

  • mapping[8] := 8

  • solve(1, 1, 10, N)

  • solve(6, 9, 10, N)

  • solve(9, 6, 10, N)

  • solve(8, 8, 10, N)

  • ret लौटाएं

बेहतर समझ के लिए निम्नलिखित कार्यान्वयन देखें:

उदाहरण

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

typedef long long int lli;

class Solution {
public:
    int ret;
    map mapping;
    vector valid;

    void solve(lli num, lli rotate, lli digit, lli N) {
        if (rotate != num) {
            ret++;
        }
        for (int i = 0; i < valid.size(); i++) {
            int dig = valid[i];
            if (num * 10 + dig > N) {
                break;
            }
            solve(num * 10 + dig, mapping[dig] * digit + rotate, digit * 10, N);
        }
    }

    int confusingNumberII(int N) {
        ret = 0;
        valid = { 0, 1, 6, 8, 9 };
        mapping[0] = 0;
        mapping[1] = 1;
        mapping[6] = 9;
        mapping[9] = 6;
        mapping[8] = 8;
        solve(1, 1, 10, N);
        solve(6, 9, 10, N);
        solve(9, 6, 10, N);
        solve(8, 8, 10, N);
        return ret;
    }
};

int main() {
    Solution ob;
    cout << (ob.confusingNumberII(20));
}

इनपुट

20

आउटपुट

6
  1. - C++ में मितव्ययी संख्या (Frugal Number)

    इस समस्या में, हमें एक धनात्मक पूर्णांक N दिया गया है। हमारा कार्य यह जांचने के लिए एक प्रोग्राम बनाना है कि दी गई संख्या मितव्ययी संख्या है या नहीं। मितव्ययी संख्या (FRUGAL NUMBER) − एक संख्या जिसके अंकों की संख्या उस संख्या के अभाज्य गुणनखंडन में अंकों की संख्या से सख्ती से अधिक है। उदाहरण &

  1. C++ में पेंटाटोप संख्या C++ में पेंटाटोप संख्या

    एक पेंटाटोप संख्या को पास्कल के त्रिभुज में पांचवीं संख्या के रूप में वर्णित किया गया है। अब, चूंकि यह पांचवीं संख्या है, इसका मतलब है कि पास्कल के त्रिभुज में कम से कम पांच संख्याएं होनी चाहिए, इसलिए इस श्रृंखला की पहली संख्या 1 4 6 4 1 से शुरू होती है जो पास्कल के त्रिभुज की चौथी पंक्ति है। तो, इस

  1. - C++ में एडम नंबर जांचना

    इस खंड में हम देखेंगे कि दी गई संख्या एडम नंबर है या नहीं, इसकी जांच करने वाला प्रोग्राम कैसे लिखें। कोड में जाने से पहले देखते हैं कि एडम नंबर क्या है? एडम नंबर वह संख्या है, मान लीजिए n, यदि n का वर्ग और n के रिवर्स का वर्ग एक-दूसरे के रिवर्स हैं, तो वह संख्या एडम नंबर है। उदाहरण के लिए संख्या 13