मैं इसकी अधिकतम / न्यूनतम मान के लिए एक नाव कैसे शुरू करूं?

Question

मैं एक फ्लोट या डबल के लिए हार्ड कोड को एक पूर्ण अधिकतम या न्यूनतम मूल्य कैसे बना सकता हूं? मैं किसी सरणी के अधिकतम / मिनट को बस के माध्यम से खोज करना चाहता हूं और सबसे बड़ा पकड़ना चाहता हूं।

तैरने के लिए सकारात्मक और नकारात्मक अनंत भी हैं, क्या मुझे इसके बजाय उनका उपयोग करना चाहिए? यदि हां, तो मैं इसे अपने कोड में कैसे निरूपित करूं?

Answer 1

आप प्रकारों का न्यूनतम या अधिकतम मान std::numeric_limitsज्ञात <limits>करने के लिए उपयोग कर सकते हैं (जब तक कि कोई विशेषज्ञता प्रकार के लिए मौजूद है)। आप इसका उपयोग अनंत को पुनः प्राप्त करने के लिए भी कर सकते हैं (और -नकारात्मक अनंत के लिए सामने रख सकते हैं )।

#include <limits>

//...

std::numeric_limits<float>::max();
std::numeric_limits<float>::min();
std::numeric_limits<float>::infinity();

जैसा कि टिप्पणियों में बताया गया है, min()सबसे कम संभव सकारात्मक मूल्य देता है। दूसरे शब्दों में 0 के निकटतम सकारात्मक मान जिसे दर्शाया जा सकता है। न्यूनतम संभव मूल्य अधिकतम संभव मूल्य का नकारात्मक है।

निश्चित रूप से std::max_elementऔर min_element फ़ंक्शंस (परिभाषित <algorithm>) है जो किसी सरणी में सबसे बड़ा या सबसे छोटा मान खोजने के लिए बेहतर विकल्प हो सकता है।

Comments

मैं इसका सटीक उपयोग कैसे करूं? मुझे क्या शामिल करने की आवश्यकता है? मुझे नहीं लगता कि मैंने पहले कभी ऐसा कुछ इस्तेमाल किया है।

— फॉक्स

हम्म ... वह अधिकतम तत्व फ़ंक्शन बहुत उपयोगी होता ... यह वही होता है जब आप स्वयं कोडिंग सीखते हैं और औपचारिक रूप से नहीं। आप अंत में पहिया को 50 बार प्रबलित करते हैं। यह पिछली बार की तरह है जब मैंने छत () के बारे में सीखा। धन्यवाद।

— फुकर

@Yacoby, आप यह स्पष्ट करना चाह सकते हैं कि num_limits <float> :: min () का अर्थ सबसे नकारात्मक मान नहीं है, इसका अर्थ है सबसे छोटा सकारात्मक।

— एमएसएन

@killogre: C ++ 11 जोड़ा गया numeric_limits<T>::lowest(), जो इस समस्या को हल करने के लिए सबसे कम (ऋणात्मक) मान लौटाता है।

— कॉर्न्स्टल

std::numeric_limits<float>::min()करता नहीं छोटी से छोटी सकारात्मक मूल्य है कि प्रदर्शित किया जा सकता देते हैं; यह सबसे छोटी सामान्य एकल-सटीक फ़्लोटिंग पॉइंट संख्या देता है। शून्य और इस संख्या के बीच उप- संख्याएँ भी हैं । विशेष रूप से, std::numeric_limits<float>::min()देता है 1.17549e-38लेकिन सबसे छोटा प्रतिनिधित्व करने योग्य सबनॉर्मल फ्लोट है nextafterf(0.0f, 1.0f) == 1.4013e-45f।

— निबोट

Answer 2

आप या तो उपयोग कर सकते हैं -FLT_MAX(या -DBL_MAX) अधिकतम परिमाण नकारात्मक संख्या और के लिए FLT_MAX(या DBL_MAX) सकारात्मक के लिए। यह आपको संभावित फ्लोट (या दोहरे) मानों की श्रेणी प्रदान करता है।

आप शायद उपयोग नहीं करना चाहते हैं FLT_MIN; यह सबसे छोटी परिमाण धनात्मक संख्या से मेल खाती है जिसे एक फ्लोट के साथ दर्शाया जा सकता है, न कि एक फ्लोट के साथ सबसे अधिक निगेटिव मान।

FLT_MINऔर FLT_MAXके अनुरूप std::numeric_limits<float>::min()और std::numeric_limits<float>::max()।

Comments

मुझे लगता है कि मैं वास्तव में इस संस्करण का उपयोग करूंगा, यह याद रखने में सरल और मेरे लिए अधिक दृश्य बनाता है। इंटेगर मैं केवल हेक्साडेसिमल का उपयोग करके आरंभ कर सकता हूं। हालांकि, सबसे अच्छा जवाब अभी भी रहता है क्योंकि जवाब ने मुझे कुछ नए बेहद उपयोगी कार्यों से भी परिचित कराया।

— फुकर

"[ FLT_MIN] सबसे छोटी परिमाण सकारात्मक संख्या से मेल खाती है जिसे फ्लोट के साथ दर्शाया जा सकता है" - यह सच नहीं है । यह सबसे छोटी सामान्य संख्या है। सबनॉर्मल नंबर भी होते हैं।

— nibot

आप चाहते हैं FLT_TRUE_MINवास्तविक छोटी संभव नाव है, जो से मेल खाती है के लिएstd::numeric_limits<float>::denorm_min()

— क्रिस डोड

Answer 3

सरणी में सबसे छोटा / सबसे बड़ा खोजने के लिए सबसे छोटा / सबसे बड़ा संभव शुरू करने की कोई वास्तविक आवश्यकता नहीं है:

double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
    if (array[i] < smallest)
        smallest = array[i];
    if (array[i] > largest0
        largest= array[i];
}

या, यदि आप इसे एक से अधिक बार कर रहे हैं:

#include <utility>

template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
    std::pair<typename iter::value_type, typename iter::value_type> ret;
    ret.first = ret.second = *begin;
    while (++begin != end) {
        if (*begin < ret.first)
           ret.first = *begin;
        if (*begin > ret.second)
           ret.second = *begin;
   }
   return ret;
}

नमूना कोड प्रदान करने का नुकसान - मुझे लगता है कि दूसरों ने पहले से ही एक ही विचार का सुझाव दिया है।

ध्यान दें कि जब मानक में एक min_element और max_element होता है, तो इनका उपयोग करके दो बार डेटा के माध्यम से स्कैनिंग की आवश्यकता होती है, जो कि एक समस्या है अगर सरणी बिल्कुल भी बड़ी हो। हाल के मानकों ने इसे जोड़कर संबोधित किया है std::minmax_element, जो find_extremaऊपर के समान है (एक पास में एक संग्रह में न्यूनतम और अधिकतम दोनों तत्व खोजें)।

संपादित करें: अहस्ताक्षरित की एक सरणी में सबसे छोटे गैर-शून्य मान को खोजने की समस्या को संबोधित करना: जब वे चरम पर पहुंचते हैं, तो उन अहस्ताक्षरित मानों को "लपेटें" देखें। सबसे छोटे गैर-शून्य मान को खोजने के लिए, हम तुलना के लिए प्रत्येक को एक से घटा सकते हैं। कोई भी शून्य मान, प्रकार के लिए सबसे बड़ा संभव मान "चारों ओर लपेट" देगा, लेकिन अन्य मूल्यों के बीच संबंध बनाए रखा जाएगा। हमारे द्वारा किए जाने के बाद, हम स्पष्ट रूप से हमारे द्वारा पाए गए मूल्य में एक जोड़ देते हैं।

unsigned int min_nonzero(std::vector<unsigned int> const &values) { 
    if (vector.size() == 0)
        return 0;
    unsigned int temp = values[0]-1;
    for (int i=1; i<values.size(); i++)
        if (values[i]-1 < temp)
            temp = values[i]-1;
    return temp+1;
}

ध्यान दें कि यह अभी भी प्रारंभिक मूल्य के लिए पहले तत्व का उपयोग करता है, लेकिन हमें अभी भी किसी भी "विशेष मामले" कोड की आवश्यकता नहीं है - क्योंकि यह सबसे बड़ा संभव मूल्य के चारों ओर लपेटेगा, किसी भी गैर-शून्य मान के छोटे होने की तुलना में होगा। परिणाम सबसे छोटा नॉनजरो मूल्य होगा, या 0 यदि और केवल यदि वेक्टर में कोई गैर-शून्य मान नहीं है।

Comments

लेकिन आपको मेरे लिए इसके लिए एक +1 मिलता है!

— दान डिप्लो

मैं अधिकतम मिनटों के लिए initlize करता हूं क्योंकि कभी-कभी मैं सबसे छोटा गैर शून्य मान चाहता हूं (उदाहरण के लिए एक अहस्ताक्षरित पूर्णांक मामले में, मेरा डेटा बहुत अधिक निर्बाध शून्य है)। यह मुझे लगता है कि पहला तत्व शून्य नहीं है यह सुनिश्चित करने के लिए अतिरिक्त जांच के बजाय इसे शुरू करने के लिए मुझे समझ में आता है।

— फुकर

@ फ़ेंकें: तब भी आप एक तुलनात्मक कार्य को परिभाषित कर सकते हैं जो शून्य को सबसे बड़े संभावित मान के रूप में मानता है, इसलिए आप अभी भी उपयोग कर सकते हैं std::min_element:bool less_ignoring_zero(unsigned a, unsigned b) { if (a == 0) return false; if (b == 0) return true; return a < b; }

— अंकल बीन्स

@ जेरी: C ++ 0x आपके द्वारा बताई गई समस्या को दूर करने के लिए minmax_element जोड़ेगा। (लेकिन फिर शून्य को नजरअंदाज करना संभव नहीं होगा ...)

— अंकल बीन्स

क्या होगा यदि शुरुआती तत्व शुरुआती के समय उपलब्ध नहीं है? यह ऑनलाइन प्रसंस्करण में बहुत कुछ होता है (जैसा कि बढ़ावा :: संचयकों में)

— किलोग्रे

Answer 4

किसी सरणी के न्यूनतम को मैन्युअल रूप से खोजने के लिए आपको फ्लोट का न्यूनतम मूल्य जानने की आवश्यकता नहीं है:

float myFloats[];
...
float minimum = myFloats[0];
for (int i = 0; i < myFloatsSize; ++i)
{
  if (myFloats[i] < minimum)
  {
    minimum = myFloats[i];
  }
}

और अधिकतम मूल्य के लिए समान कोड।

Answer 5

क्या मैं आपको सुझाव दूंगा कि आप अपने "अधिकतम और न्यूनतम अब तक" वेरिएबल्स को अनंत तक नहीं, बल्कि सरणी में पहले नंबर पर लाएँ?