C++ में लक्ष्य को पूरा करने के लिए गोलाई त्रुटि को कम करें

मान लीजिए कि हमारे पास कीमतों की एक सरणी है पी [पी 1, पी 2 ..., पीएन] और एक लक्ष्य मूल्य, हमें प्रत्येक मूल्य पीआई से राउंडी (पीआई) को गोल करना होगा ताकि गोलाकार सरणी [राउंड 1 (पी 1), राउंड 2 (पी 2) ...,Roundn(Pn)] दिए गए लक्ष्य मान का योग है। यहां प्रत्येक ऑपरेशन राउंडी (पीआई) या तो तल (पाई) या छत (पाई) हो सकता है।

यदि गोल सरणी को लक्ष्य के लिए योग करना असंभव है, तो हमें स्ट्रिंग "-1" को वापस करना होगा। अन्यथा, सबसे छोटी गोलाई त्रुटि लौटाएं, जो (दशमलव के बाद तीन स्थानों वाली एक स्ट्रिंग के रूप में) के रूप में परिभाषित होगी -

$\displaystyle\sum\limits_{i-1}^n |Round_{i} (???? ) - ????$

इसलिए यदि इनपुट ["0.700", "2.800", "4.900"] जैसा है, और लक्ष्य 8 है। (0.7 - 0) + (3 - 2.8) + (5 - 4.9) प्राप्त करने के लिए फर्श या छत के संचालन का उपयोग करें। =0.7 + 0.2 + 0.1 =1.0

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

• रिट:=0

• जटिल डेटा टाइप करने के लिए (डबल और सरणी) के लिए एक प्राथमिकता कतार pq बनाएं

• मेरे लिए 0 से लेकर कीमतों के आकार के बीच

  • x :=कीमतों का दोहरा मूल्य[i]

  • निम्न :=x का तल

  • उच्च :=x की अधिकतम सीमा

  • यदि निम्न उच्च नहीं है

    • अंतर :=(उच्च - x) - (x - निम्न)

    • pq में अंतर डालें

  • लक्ष्य :=लक्ष्य – कम

  • रिट :=रिट + (एक्स - लो)

• यदि लक्ष्य> pq का आकार या लक्ष्य <0 है, तो "-1" पर लौटें

• जबकि लक्ष्य 0 नहीं है

  • ret :=ret + pq के ऊपर, pq से हटाएं

  • डी

  • लक्ष्य को 1 से घटाएं

• s :=स्ट्रिंग के रूप में रिट करें

• तीन दशमलव स्थानों तक संख्या लेकर सबस्ट्रिंग s वापस करें

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

उदाहरण

#include <bits/stdc++.h>
using namespace std;
struct Comparator{
   bool operator()(double a, double b) {
      return !(a < b);
   }
};
class Solution {
   public:
   string minimizeError(vector<string>& prices, int target) {
      double ret = 0;
      priority_queue < double, vector < double >, Comparator > pq;
      for(int i = 0; i < prices.size(); i++){
         double x = stod(prices[i]);
         double low = floor(x);
         double high = ceil(x);
         if(low != high){
            double diff = ((high - x) - (x - low));
            pq.push(diff);
         }
         target -= low;
         ret += (x - low);
      }
      if(target > pq.size() || target < 0) return "-1";
      while(target--){
         ret += pq.top();
         pq.pop();
      }
      string s = to_string (ret);
      return s.substr (0, s.find_first_of ('.', 0) + 4);
   }
};
main(){
   vector<string> v = {"0.700","2.800","4.900"};
   Solution ob;
   cout << (ob.minimizeError(v, 8));
}

इनपुट

["0.700","2.800","4.900"]
8

आउटपुट

"1.000"