मैं वेक्टर में अधिकतम (या मिनट) मान कैसे प्राप्त कर सकता हूं?

Question

मैं C ++ में वेक्टर में अधिकतम (या मिनट) मान कैसे प्राप्त कर सकता हूं ?

मैंने Google पर इसके लिए कुछ समाधान देखे हैं, लेकिन उनमें से किसी ने भी मुझे इससे कोई मतलब नहीं है :(

क्या कोई आसान सरल तरीके से समझा सकता है कि वेक्टर से अधिकतम या न्यूनतम मान कैसे प्राप्त करें? और क्या मैं यह मानने में गलत हूं कि यह एक सरणी के साथ कम या ज्यादा होगा?

मुझे एक पुनरावृत्ति अधिकार की आवश्यकता है? मैं इसके साथ की कोशिश की, max_elementलेकिन एक त्रुटि हो रही रखा?

vector<int>::const_iterator it;
it = max_element(cloud.begin(), cloud.end());

त्रुटि: 'क्लाउड' में सदस्य 'आरंभ' के लिए अनुरोध, जो गैर-श्रेणी प्रकार 'int [10]' का है

संपादित करें: मैं अपने खुद के जवाब देने में सक्षम नहीं था ??? तो मैं इसे यहाँ रखूँगा ...

वाह, तेजी से जवाब के लिए धन्यवाद! मैंने इसे इस तरह से पूरा किया, क्या यह ठीक है?

for (unsigned int i = 0; i < cdf.size(); i++)
  if (cdf[i] < cdfMin)
    cdfMin = cdf[i];

cdfवेक्टर कहां है

Comments

ऐसा लगता है कि cloudएसटीएल कंटेनर नहीं है, बल्कि ए int[10]। असल में, cloudएक सदस्य नहीं है .begin()। जब तक आप केवल एक चीज़ नहीं कर रहे हैं, तब तक एक मूल C ++ पुस्तक प्राप्त करना चाहते हैं।

— क्रिस ए।

कुछ और कोड उपयोगी हो सकते हैं। बादल की परिभाषा कहाँ है?

— टिम

@bobblob: और फिर भी आपके द्वारा पोस्ट किए गए कंपाइलर एरर ने कहा कि "क्लाउड नॉन-क्लास टाइप का है int[10]"। यह एक वेक्टर कैसे हो सकता है?

— jalf

Answer 1

C ++ 11 / c ++ 0x संकलित झंडे का उपयोग करके, आप कर सकते हैं

auto it = max_element(std::begin(cloud), std::end(cloud)); // c++11

अन्यथा, अपना स्वयं का लिखें:

template <typename T, size_t N> const T* mybegin(const T (&a)[N]) { return a; }    
template <typename T, size_t N> const T* myend  (const T (&a)[N]) { return a+N; }

इसे http://ideone.com/aDkhW पर लाइव देखें :

#include <iostream>
#include <algorithm>

template <typename T, size_t N> const T* mybegin(const T (&a)[N]) { return a; }    
template <typename T, size_t N> const T* myend  (const T (&a)[N]) { return a+N; }

int main()
{
    const int cloud[] = { 1,2,3,4,-7,999,5,6 };

    std::cout << *std::max_element(mybegin(cloud), myend(cloud)) << '\n';
    std::cout << *std::min_element(mybegin(cloud), myend(cloud)) << '\n';
}

ओह, और उपयोग करेंstd::minmax_element(...) यदि आपको एक साथ दोनों की आवश्यकता है: /

Comments

नमस्ते, क्या आप जानते हैं कि इसे आयाम सरणी या वेक्टर पर लागू करना संभव है?

— चार्ल्स चाउ

हाँ तुम कर सकते हो। मानक पुस्तकालय एल्गोरिदम को पुनरावृत्तियों पर उदारतापूर्वक कार्य करने के लिए डिज़ाइन किया गया है। सूचक भी पुनरावृत्त होते हैं।

— सेह

Answer 2

यदि आप फ़ंक्शन का उपयोग करना चाहते हैं std::max_element(), तो आपको इसे करना होगा:

double max = *max_element(vector.begin(), vector.end());
cout<<"Max value: "<<max<<endl;

मुझे उम्मीद है कि यह मदद कर सकता है।

Comments

क्यों होती है *में *max_element?

— कोनराड

ऐसा इसलिए है क्योंकि ismax_element´returns एक पुनरावृत्ति

— एंजी क्विजानो

मुझे लगता है कि आपने इनपुट को वेक्टर <double> मान लिया है या डिफ़ॉल्ट रिटर्न डबल वैल द्वारा * max_element () करता है।

— समीर काप

Answer 3

चलो,

 #include <vector>

 vector<int> v {1, 2, 3, -1, -2, -3};

यदि वेक्टर को आरोही या अवरोही क्रम में क्रमबद्ध किया जाता है तो आप इसे जटिलता ओ (1) के साथ पा सकते हैं।

आरोही क्रम के एक वेक्टर के लिए पहला तत्व सबसे छोटा तत्व है, आप इसे v [0] (0 आधारित अनुक्रमण) द्वारा प्राप्त कर सकते हैं और अंतिम तत्व सबसे बड़ा तत्व है, आप इसे v [sizeOfVector-1] से प्राप्त कर सकते हैं।

यदि वेक्टर को अवरोही क्रम में क्रमबद्ध किया जाता है तो अंतिम तत्व सबसे छोटा तत्व है, आप इसे v [sizeOfVector-1] द्वारा प्राप्त कर सकते हैं और पहला तत्व सबसे बड़ा तत्व है, आप इसे v [0] तक प्राप्त कर सकते हैं।

यदि वेक्टर सॉर्ट नहीं किया जाता है, तो आपको सबसे छोटा / सबसे बड़ा तत्व प्राप्त करने के लिए वेक्टर पर पुनरावृत्त करना होगा। इस मामले में समय जटिलता O (n) है, यहाँ n वेक्टर का आकार है।

int smallest_element = v[0]; //let, first element is the smallest one
int largest_element = v[0]; //also let, first element is the biggest one
for(int i = 1; i < v.size(); i++)  //start iterating from the second element
{
    if(v[i] < smallest_element)
    {
       smallest_element = v[i];
    }
    if(v[i] > largest_element)
    {
       largest_element = v[i];
    }
}

आप पुनरावृत्ति का उपयोग कर सकते हैं,

for (vector<int>:: iterator it = v.begin(); it != v.end(); it++)
{
    if(*it < smallest_element) //used *it (with asterisk), because it's an iterator
    {
      smallest_element = *it;
    }
    if(*it > largest_element)
    {
      largest_element = *it;
    }
}

आप इसे इनपुट अनुभाग में गणना कर सकते हैं (जब आपको किसी दिए गए वेक्टर से सबसे छोटा या सबसे बड़ा तत्व ढूंढना है)

int smallest_element, largest_element, value;
vector <int> v;
int n;//n is the number of elements to enter
cin >> n;
for(int i = 0;i<n;i++)
{
    cin>>value;
    if(i==0)
    {
        smallest_element= value; //smallest_element=v[0];
        largest_element= value; //also, largest_element = v[0]
    }

    if(value<smallest_element and i>0)
    {
        smallest_element = value;
    }

    if(value>largest_element and i>0)
    {
        largest_element = value;
    }
    v.push_back(value);
}

इसके अलावा, आप कार्यों में निर्मित सबसे छोटा / सबसे बड़ा तत्व प्राप्त कर सकते हैं

#include<algorithm>

int smallest_element = *min_element(v.begin(),v.end());

int largest_element  = *max_element(v.begin(),v.end());

आप इस फ़ंक्शन का उपयोग करके किसी भी सीमा का सबसे छोटा / सबसे बड़ा तत्व प्राप्त कर सकते हैं। जैसे कि,

vector<int> v {1,2,3,-1,-2,-3};

cout << *min_element(v.begin(), v.begin() + 3); //this will print 1,smallest element of first three elements

cout << *max_element(v.begin(), v.begin() + 3); //largest element of first three elements

cout << *min_element(v.begin() + 2, v.begin() + 5); // -2, smallest element between third and fifth element (inclusive)

cout << *max_element(v.begin() + 2, v.begin()+5); //largest element between third and first element (inclusive)

मैंने min_element () / max_element () फ़ंक्शन से पहले तारांकन (*) का उपयोग किया है। क्योंकि दोनों ही पुनरावृति लौटाते हैं। सभी कोड c ++ में हैं।

Comments

min_elementऔर max_elementएक पुनरावृत्त लौटाएं , सूचक नहीं। हालाँकि, तकनीकी रूप से सही होने के लिए एक सूचक एक सबसेट का उपसमूह है। देखें: stackoverflow.com/questions/2728190/…

— किरण

मैंने अपना उत्तर अपडेट कर दिया है। आपके अवलोकन के लिए धन्यवाद।

— तौहीदुल इस्लाम

Answer 4

यह मानते हुए कि int cloud[10]आप ऐसा कर सकते हैं: int *p = max_element(cloud, cloud + 10);

Comments

यह भी कोशिश करो। मैंने पहले तो कोशिश की कि ज्यादा से ज्यादा मैसेज किया जाए लेकिन प्यार नहीं। धन्यवाद!

— बॉब ब्लॉब

Answer 5

आप इसे सीधे max_element / min_element फ़ंक्शन का उपयोग करके प्रिंट कर सकते हैं। उदाहरण के लिए:

  cout<<*max_element(v.begin(),v.end());

  cout<<*min_element(v.begin(),v.end());

Answer 6

C ++ 11 में, आप कुछ फ़ंक्शन का उपयोग कर सकते हैं जैसे:

int maxAt(std::vector<int>& vector_name) {
    int max = INT_MIN;
    for (auto val : vector_name) {
         if (max < val) max = val;
    }
    return max;
}

Comments

जब से आप C ++ 11 का संदर्भ दे रहे हैं, यह उपयोग करने से बेहतर है std::max_elementक्योंकि ...?

— रेयिनेंग

Answer 7

यदि आप एक पुनरावृत्त का उपयोग करना चाहते हैं, तो आप एक सरणी के साथ प्लेसमेंट-नया कर सकते हैं ।

std::array<int, 10> icloud = new (cloud) std::array<int,10>;

की कमी पर ध्यान दें () अंत , यह महत्वपूर्ण है। यह एक एरे क्लास बनाता है जो उस मेमोरी को अपने स्टोरेज के रूप में इस्तेमाल करता है, और इसमें एसटीएल फीचर होते हैं जैसे कि इटैटर।

(यह है C ++ TR1 / C ++ 11 वैसे)

Answer 8

वेक्टर में अधिकतम मूल्य प्राप्त करने के लिए आप max_element का उपयोग कर सकते हैं। Max_element श्रेणी में सबसे बड़े मान के लिए पुनरावृत्ति देता है, या यदि श्रेणी खाली है, तो अंतिम है। चूँकि एक iterator पॉइंटर्स की तरह होता है (या आप कह सकते हैं कि पॉइंटर एक प्रकार का itter है), तो आप वेल्यू पाने के लिए पहले एक * का उपयोग कर सकते हैं। तो समस्या के अनुसार आप एक वेक्टर में अधिकतम तत्व प्राप्त कर सकते हैं:

int max=*max_element(cloud.begin(), cloud.end());

यह आपको आपके वेक्टर "क्लाउड" में अधिकतम तत्व देगा। आशा करता हूँ की ये काम करेगा।

Answer 9

सिर्फ यह:

// assuming "cloud" is:
// int cloud[10]; 
// or any other fixed size

#define countof(x) (sizeof(x)/sizeof((x)[0]))

int* pMax = std::max_element(cloud, cloud + countof(cloud));

Comments

मैक्रोज़ का उपयोग क्यों करें? उसका कोई कारण नहीं है! त्रुटि के साथ शुरू होता है int cloud[10];और यह जादू की संख्या का उपयोग है।

— उलरिच एकहार्ट

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

— ivan.ukr 10

क्षमा करें, यह सही ढंग से नहीं आया। आपका समाधान सही है, लेकिन बुरा है। कारण यह है कि यह मैजिक नंबरों के उपयोग को मानता है, जो त्रुटि संदेश का पालन नहीं करता है। यह तब मैक्रोज़ के उपयोग के साथ जारी रहता है, जो हमेशा एक कोड गंध होते हैं।

— उलरिच एकहार्ट

Answer 10

#include <stdlib.h>
#include <stdio.h>

int main()
{

    int vector[500];

    vector[0] = 100;
    vector[1] = 2;
    vector[2] = 1239;
    vector[3] = 5;
    vector[4] = 10;
    vector[5] = 1;
    vector[6] = 123;
    vector[7] = 1000;
    vector[8] = 9;
    vector[9] = 123;
    vector[10] = 10;

    int i = 0;

    int winner = vector[0];

    for(i=0;i < 10; i++)
    {
        printf("vector = %d \n", vector[i]);

        if(winner > vector[i])
        {
            printf("winner was %d \n", winner);
            winner = vector[i];
            printf("but now is %d \n", winner);
        }
    }

    printf("the minimu is %d", winner);
}

पूरा nooby तरीका ... C में

Comments

यह इस सवाल का जवाब देता है कि किसी सरणी में अधिकतम मान कैसे पाया जाए, C ++ नहींvector

— एंड्रयू स्टब्स

इस प्रश्न को C ++ टैग किया गया है। आपने इस कोड को C में लिखा है, लेकिन इतना ही नहीं, आप एक वेक्टर को एक सरणी के बराबर कर रहे हैं - सही नहीं। जब आपके पास वास्तविक मूल्य की आवश्यकता होती है तो आपके पास अनावश्यक प्रिंट स्टेटमेंट भी होते हैं। अंत में, पूरा कोड विचलित कर रहा है। आपको बस forलूप में कोड की आवश्यकता है । कुल मिलाकर बहुत ही घटिया जवाब।

— रेयेंग डेंगू