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

C++ में 4 से विभाज्य घूर्णनों की गणना करें

हमें बड़ी संख्या में दिया गया है। लक्ष्य संख्या के घुमावों की गणना करना है जो 4 से विभाज्य हैं।

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

आइए उदाहरणों से समझते हैं।

इनपुट - संख्या=15324

आउटपुट − 4 से विभाज्य घूर्णनों की संख्या हैं:2

स्पष्टीकरण - घुमाव हैं -

15324, 41532, 24153, 32415, 53241

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

इनपुट - संख्या=848484

आउटपुट − 4 से विभाज्य घूर्णनों की संख्या है − 6

स्पष्टीकरण - घुमाव हैं -

848484, 484848, 848484, 484848, 848484, 484848

ये सभी घुमाव 4 से विभाज्य हैं

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

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

  • संख्या को लंबी संख्या के रूप में लें।

  • फ़ंक्शन Rotation_4(long long num) संख्या संख्या लेता है और संख्या के घूर्णन की संख्या देता है जो 4 से विभाज्य हैं।

  • संख्या को स्ट्रिंग में बदलें str=to_string(num).

  • अंकों में अंकों की संख्या लंबाई =str.length() होगी।

  • अंकों के जोड़े के पूर्णांक मानों को संग्रहीत करने के लिए अस्थायी चर अंक =0 लें।

  • प्रारंभिक गणना 0 के रूप में लें।

  • यदि लंबाई 1 है तो केवल एक अंक मौजूद है। इसे पूर्णांक में बदलें, digit=(str.at(0)-'0')

  • 4 से विभाज्यता की जाँच करें और परिणाम को 1 या 0 के रूप में लौटाएँ।

  • अब लूप के लिए i=0 से I

  • 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 से विभाज्य है

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

  1. C++ में 8 से विभाज्य घूर्णनों की गणना करें

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

  1. सी ++ में क्रमबद्ध और घुमाए गए लिंक्ड सूची में घूर्णन की गणना करें

    हमें एक लिंक्ड लिस्ट दी गई है। सूची को पहले क्रमबद्ध किया जाता है और फिर K संख्या के नोड्स द्वारा घुमाया जाता है। लक्ष्य K का मान ज्ञात करना है। यदि हमें इनपुट के रूप में लिंक की गई सूची नीचे दी गई है, जिसे K नोड्स की संख्या द्वारा घुमाया जाता है - तब मूल अवश्य रहा होगा - और हम देख सकते हैं K