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

C++ में चार डिवाइजर्स


मान लीजिए हमारे पास एक इंटीजर ऐरे nums है, हमें उस ऐरे में उन इंटीजर्स के डिवाइजर्स का योग ढूंढना है जिनके ठीक चार डिवाइजर्स हैं। अगर ऐरे में ऐसा कोई इंटीजर नहीं है, तो 0 लौटाएं। उदाहरण के लिए, अगर इनपुट [21, 4, 7] है, तो आउटपुट 32 होगा, क्योंकि 21 के चार डिवाइजर्स हैं 1, 3, 7, 21, 4 के तीन डिवाइजर्स हैं 1, 2, 4, और 7 के दो डिवाइजर्स हैं 1 और 7। उत्तर केवल 21 के डिवाइजर्स का योग है।

इसे हल करने के लिए, हम इन स्टेप्स को फॉलो करेंगे:

  • ok() नाम का एक मेथड डिफाइन करें, जो x को इनपुट के रूप में लेगा

  • ret := 1 + x, cnt := 2

  • i := 2 से, i^2 <= x तक, i को 1 से बढ़ाएं:

    • अगर x i से डिविजिबल है:

      • ret को i से बढ़ाएं, cnt को 1 से बढ़ाएं

      • अगर i, x/i के बराबर नहीं है, तो cnt को 1 से बढ़ाएं, ret := ret + (x/i)

  • ret लौटाएं, अगर cnt 4 है, अन्यथा 0 लौटाएं

  • मेन मेथड से:

    • ret := 0, n := nums का साइज

    • i को 0 से n-1 तक लूप करें:

      • ret := ret + ok(nums[i])

    • ret लौटाएं

उदाहरण (C++)

बेहतर समझ के लिए निम्न इम्प्लीमेंटेशन देखें:

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

class Solution {
public:
    int ok(int x){
        int ret = 1 + x;
        int cnt = 2;
        for(int i = 2; i * i <= x; i++){
            if(x % i == 0){
                ret += (i);
                cnt++;
                if(i != x / i){
                    cnt++;
                    ret += (x / i);
                }
            }
        }
        return cnt == 4 ? ret : 0;
    }
    int sumFourDivisors(vector<int>& nums) {
        int ret = 0;
        int n = nums.size();
        for(int i = 0; i < n; i++){
            ret += ok(nums[i]);
        }
        return ret;
    }
};

int main(){
    vector<int> v = {21,4,7};
    Solution ob;
    cout << (ob.sumFourDivisors(v));
}

इनपुट

[21,4,7]

आउटपुट

32

  1. C++ में जंप गेम V C++ में जंप गेम V

    मान लीजिए हमारे पास arr नामक पूर्णांकों की एक सरणी और एक पूर्णांक d है। एक चरण में हम इंडेक्स i से कूद सकते हैं: i + x जहां: i + x < n और x की सीमा 1 से d है। = 0 और x की सीमा 1 से d है। arr[k] हो। हम सरणी के किसी भी इंडेक्स से कूदना शुरू कर सकते हैं। हमें अधिकतम इंडेक्स की संख्या ज्ञात करनी है ज

  1. - C++ में K डिजिट्स हटाना

    मान लीजिए हमारे पास एक नॉन-नेगेटिव इंटीजर num है जिसे स्ट्रिंग के रूप में दर्शाया गया है, हमें नंबर से k डिजिट्स हटाने हैं ताकि नया नंबर सबसे छोटा संभव हो। उदाहरण के लिए, अगर इनपुट 1432219 है और k = 3, तो रिजल्ट 1219 होगा। इसे हल करने के लिए, हम इन स्टेप्स को फॉलो करेंगे: एक स्टैक st डिफाइन करें,

  1. - C++ में क्लोजेस्ट डिवाइजर्स

    मान लीजिए हमारे पास एक इंटीजर num है, हमें एब्सोल्यूट डिफरेंस में सबसे निकट दो इंटीजर्स ढूंढने हैं जिनका गुणनफल num + 1 या num + 2 के बराबर हो। हमें किसी भी क्रम में दो इंटीजर्स ढूंढने हैं। उदाहरण के लिए, अगर इनपुट 8 है, तो आउटपुट [3, 3] होगा, num + 1 के लिए यह 9 होगा, क्लोजेस्ट डिवाइजर्स 3 और 3 है