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

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

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

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

• diff := इनफिनिटी, साइज 2 का एक ऐरे ret बनाएं

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

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

    • a := i

    • b := x / i

    • newDiff := |a - b|

    • अगर newDiff < diff, तो:

      • diff := newDiff

      • ret[0] := a और ret[1] := b

• ret लौटाएं

• मेन मेथड से op1 := getDiv(num + 1) और op2 := getDiv(num + 2) ढूंढें

• op1 लौटाएं जब |op1[0] - op1[1]| <= |op2[0] - op2[1]|, अन्यथा op2

उदाहरण (C++)

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

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

void print_vector(vector<auto> v){
    cout << "[";
    for(int i = 0; i<v.size(); i++){
        cout << v[i] << ", ";
    }
    cout << "]"<<endl;
}

class Solution {
public:
    vector <int> getDiv(int x){
        int diff = INT_MAX;
        vector <int> ret(2);
        for(int i = 1; i * i <= x; i++){
            if(x % i == 0){
                int a = i;
                int b = x / i;
                int newDiff = abs(a - b);
                if(newDiff < diff){
                    diff = newDiff;
                    ret[0] = a;
                    ret[1] = b;
                }
            }
        }
        return ret;
    }
    vector<int> closestDivisors(int num) {
        vector <int> op1 = getDiv(num + 1);
        vector <int> op2 = getDiv(num + 2);
        return abs(op1[0] - op1[1]) <= abs(op2[0] - op2[1]) ? op1 : op2;
    }
};

int main(){
    Solution ob;
    print_vector(ob.closestDivisors(8));
}

इनपुट

8

आउटपुट

[3,3]