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

C++ में 4 से विभाज्य रोटेशन की गिनती


हमें एक बड़ी संख्या दी गई है। लक्ष्य num के उन रोटेशन की संख्या गिनना है जो 4 से विभाज्य हैं।

चूंकि रोटेशन को बार-बार नहीं किया जा सकता। हम 4 से विभाज्यता के गुणधर्म का उपयोग करेंगे। यदि अंतिम दो अंक 4 से विभाज्य हैं तो संख्या 4 से विभाज्य है। यदि संख्या 1234 है तो इसके रोटेशन होंगे 1234, 4123, 3412, 2341 जिनमें से 3412, 4 से विभाज्य होगा क्योंकि इसके अंतिम दो अंक 12, 4 से विभाज्य हैं।

उदाहरण सहित समझ

इनपुट - num=15324

आउटपुट - 4 से विभाज्य रोटेशन की संख्या: 2

व्याख्या - रोटेशन हैं:

15324, 41532, 24153, 32415, 53241
इनमें से 15324 और 41532, 4 से विभाज्य होंगे।

इनपुट - num=848484

आउटपुट - 4 से विभाज्य रोटेशन की संख्या: 6

व्याख्या - रोटेशन हैं:

848484, 484848, 848484, 484848, 848484, 484848
ये सभी रोटेशन 4 से विभाज्य हैं।

प्रोग्राम में उपयोग किया गया दृष्टिकोण

हम संख्या को स्ट्रिंग में बदलेंगे और फॉर लूप का उपयोग करके संख्या को ट्रैवर्स करेंगे। प्रत्येक दो अंकों के जोड़े के लिए उन्हें पूर्णांक में बदलें और 4 से विभाज्यता जांचें। यदि विभाज्य है तो काउंट बढ़ाएँ।

  • संख्या को long long num के रूप में लें।
  • फंक्शन Rotation_4(long long num) संख्या num लेता है और num के उन रोटेशन की संख्या लौटाता है जो 4 से विभाज्य हैं।
  • num को स्ट्रिंग में बदलें: str = to_string(num)।
  • num में अंकों की संख्या होगी length = str.length()।
  • अंकों के जोड़े के पूर्णांक मान संग्रहीत करने के लिए अस्थायी चर digit = 0 लें।
  • प्रारंभिक काउंट 0 लें।
  • यदि लंबाई 1 है तो केवल एक अंक मौजूद है। इसे पूर्णांक में बदलें: digit = (str.at(0) - '0')। 4 से विभाज्यता जांचें और परिणाम 1 या 0 के रूप में लौटाएँ।
  • अब फॉर लूप का उपयोग करके i=0 से i<length-1 तक str को ट्रैवर्स करें।
  • दो अंकों की संख्या बनाएँ: digit = (str.at(i) - '0') * 10 + (str.at(i+1) - '0') क्योंकि प्रत्येक जोड़ा रोटेशन में अंतिम दो अंक बनेगा।
  • अंतिम अंक और पहले अंक से बने जोड़े के लिए वही प्रक्रिया दोहराएँ: digit = (str.at(length-1) - '0') * 10 + (str.at(0) - '0')। 4 से विभाज्यता जांचें और काउंट अपडेट करें।
  • अंत में परिणाम के रूप में काउंट लौटाएँ।

उदाहरण

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

int Rotation_4(long long num) {
    string str = to_string(num);
    int length = str.length();
    int digit = 0, count = 0;
    if (length == 1) {
        digit = (str.at(0) - '0');
        if (digit % 4 == 0) {
            return 1;
        } else {
            return 0;
        }
    }
    for (int i = 0; i < (length - 1); i++) {
        digit = (str.at(i) - '0') * 10 + (str.at(i + 1) - '0');
        if (digit % 4 == 0) {
            count++;
        }
    }
    digit = (str.at(length - 1) - '0') * 10 + (str.at(0) - '0');
    if (digit % 4 == 0) {
        count++;
    }
    return count;
}

int main() {
    long long num = 24040;
    cout << "Count of rotations divisible by 4 are: " << Rotation_4(num);
    return 0;
}

आउटपुट

Count of rotations divisible by 4 are: 4
  1. - C++ में उन सबएरे को गिनना जिनका गुणनफल k से विभाज्य है

    एक सरणी arr[] और एक पूर्णांक k इनपुट के रूप में दिया गया है। लक्ष्य arr[] के उन सबएरे की संख्या ढूंढना है जिनके एलिमेंट्स का गुणनफल k से विभाज्य है। उदाहरण के लिए इनपुट arr[] = {2, 1, 5, 8} k=4 आउटपुट Count of sub-arrays whose product is divisible by k are: 4 व्याख्या सबएरे होंगे: [ 8 ], [ 5,8 ], [

  1. - C++ में 8 से विभाज्य रोटेशन की गिनती

    हमें एक बड़ी संख्या दी गई है। लक्ष्य num के उन रोटेशन की संख्या गिनना है जो 8 से विभाज्य हैं। चूंकि रोटेशन को बार-बार नहीं किया जा सकता। हम 8 से विभाज्यता के गुणधर्म का उपयोग करेंगे। यदि अंतिम तीन अंक 8 से विभाज्य हैं तो संख्या 8 से विभाज्य है। यदि संख्या 1800 है तो इसके रोटेशन होंगे 1800, 0180, 00

  1. C++ में सॉर्टेड और रोटेटेड लिंक्ड लिस्ट में रोटेशन की गिनती C++ में सॉर्टेड और रोटेटेड लिंक्ड लिस्ट में रोटेशन की गिनती

    हमें एक लिंक्ड लिस्ट दी गई है। लिस्ट पहले सॉर्ट की गई है और फिर K नोड्स द्वारा रोटेट की गई है। लक्ष्य K का मान ज्ञात करना है। यदि हमें नीचे दी गई लिंक्ड लिस्ट इनपुट के रूप में दी गई है जो K नोड्स द्वारा रोटेटेड है: तो मूल लिस्ट रही होगी: और हम यहाँ देख सकते हैं K=2 है। इनपुट लिंक्ड लिस्ट मूल सॉर्