Interview Question: Best Time to Buy and Sell Stock C++
Company Interviews Using C++ Data Structures and Algorithms
int maxProfit(vector<int> &prices) {
int maxPro = 0;
int minPrice = INT_MAX;
for(int i = 0; i < prices.size(); i++){
minPrice = min(minPrice, prices[i]);
maxPro = max(maxPro, prices[i] - minPrice);
}
return maxPro;
}English :
This C++ code defines a function `maxProfit` that takes a reference to a vector of integers called `prices` as its input and calculates the maximum profit that can be obtained from buying and selling a stock. The code employs a straightforward algorithm known as “buy low, sell high.”
Here’s a step-by-step explanation of the code:
1. Initialize `maxPro` to 0: `maxPro` will store the maximum profit achieved throughout the iteration.
2. Initialize `minPrice` to `INT_MAX`: `minPrice` keeps track of the minimum price of the stock seen so far. It is initialized to a very high value to ensure it gets updated in the first iteration.
3. Use a for loop to iterate through the `prices` vector:
— For each element at index `i` in the `prices` vector:
— Update `minPrice` by taking the minimum of its current value and the price at index `i`. This ensures that `minPrice` always holds the minimum stock price seen so far.
— Calculate the profit that would be obtained by selling the stock at the price at index `i` minus the minimum price seen so far. Update `maxPro` with the maximum of its current value and this profit.
The key idea here is that the code keeps track of the minimum price encountered while iterating through the `prices` vector and calculates the profit that can be obtained if the stock is sold at each price. By maximizing this profit, you find the maximum profit achievable for the given stock price data.
After iterating through all prices in the vector, the function returns `maxPro`, which contains the maximum profit that can be achieved.
In essence, this code efficiently solves the problem of finding the maximum profit that can be obtained by buying and selling a stock when you have access to a historical list of stock prices.
Hindi :
यह C++ कोड एक फ़ंक्शन `maxProfit` को परिभाषित करता है जो अपने इनपुट के रूप में एक पूर्णांक वेक्टर का संदर्भ लेता है, जिसे `prices` कहा जाता है, और यह निवेश करके और स्टॉक खरीदने और बेचने से प्राप्त की जा सकने वाला अधिकतम लाभ की गणना करता है। कोड एक सीधा-साधा एल्गोरिथम का उपयोग करता है जिसे “सस्ता खरीदें, महंगा बेचें” के रूप में जाना जाता है।
यहां कोड की चरण-दर-चरण व्याख्या है:
1. `maxPro` को 0 पर आरंभ करें: `maxPro` इस आवर्तन के दौरान प्राप्त किए गए अधिकतम लाभ को संग्रहित करेगा।
2. `minPrice` को `INT_MAX` पर आरंभ करें: `minPrice` सो देखे गए स्टॉक की न्यूनतम मूल्य का पता रखता है। यह पहले आवर्तन में अद्यतित होने की सुनिश्चित करने के लिए बहुत उच्च मूल्य पर आरंभ किया जाता है।
3. `prices` वेक्टर के माध्यम से आवर्तन करने के लिए एक for लूप का उपयोग करें:
— `prices` वेक्टर में निम्नलिखित उपयोगकर्ता के सूची के प्रत्येक तत्व के लिए:
— `minPrice` को उसके वर्तमान मूल्य और उसके निम्नान्कित सूची के स्थल पर मूल्य की तुलना करके अद्यतित करें। यह सुनिश्चित करता है कि `minPrice` हमेशा सो देखे गए स्टॉक मूल्य को संग्रहण करता है।
— सो देखे गए स्थल पर मूल्य पर स्टॉक बेचने से प्राप्त किया जाने वाला लाभ गणना करें। इस लाभ को उसके वर्तमान मूल्य और इस लाभ की अधिकतम गणना के साथ अद्यतित करें।
यहां की मुख्य विचार यह है कि कोड `prices` वेक्टर के माध्यम से आवर्तन करते समय सो देखे गए न्यूनतम मूल्य का पता रखता है और प्रत्येक मूल्य पर स्टॉक बेचा जाता है तो प्राप्त किए जाने वाले लाभ की गणना करता है। इस लाभ को अधिकतम करके, आप दिए गए स्टॉक मूल्य डेटा के लिए प्राप्त किए जाने वाले अधिकतम लाभ को पाते हैं।
वेक्टर में सभी मूल्यों के माध्यम से आवर्तन करने के बाद, फ़ंक्शन `maxPro` को लौटाता है, जिसमें अधिकतम प्राप्ति होती है।
मूल रूप से, यह कोड एक ऐसी समस्या को प्रभावी रूप से हल करता है जिसमें एक
ऐतिहासिक सूची स्टॉक मूल्यों की विशिष्टता के साथ स्टॉक खरीदने और बेचने से प्राप्त की जाने वाली अधिकतम प्राप्ति की खोज की जाती है।
Hinglish :
Is C++ mein likhi code ek function `maxProfit` ko define karti hai, jo ek integers ke vector `prices` ka reference input leti hai aur stock ko kharidne aur bechne se prapt kiya ja sakne wala adhikatam labh nikalne ke liye use karta hai. Is code mein ek seedha-sadha algorithm ka upayog kiya gaya hai jo “sasta khareedo, mehnga bhecho” ke naam se prasiddh hai.
Yahan ek kadam se kadam vyakhya hai:
1. `maxPro` ko 0 se shuru karo: `maxPro` yeh store karega ki kaunsa adhikatam labh prapt kiya gaya hai prati avritti ke dauraan.
2. `minPrice` ko `INT_MAX` se shuru karo: `minPrice` yeh track rakhta hai ki ab tak dekhi gayi stock ki nyuntam mulya. Yeh pehle avritti mein update ho, iske liye yeh bahut adhik mulya se shuru kiya jata hai.
3. `prices` vector ke saath ek for loop ka upayog karo:
— Har ek element par index `i` mein `prices` vector mein:
— `minPrice` ko uske vartaman mulya aur index `i` par mulya ke bich ka minimum lekar update karo. Yeh yeh surakshit karta hai ki `minPrice` hamesha ab tak dekhi gayi stock ki nyuntam mulya ko dharta hai.
— Us mulya se prapt kiya ja sakne wala labh nikalo jo index `i` par mulya par stock bechkar prapt kiya ja sakta hai aur ab tak dekhi gayi nyuntam mulya ko ghataya jata hai. `maxPro` ko uske vartaman mulya aur is labh mein se adhik mulya se update karo.
Yahan ki mukhya soch yeh hai ki code `prices` vector mein aavritti karne ke dauran ab tak dekhi gayi nyuntam mulya ka pata rakhta hai aur har mulya par stock ko bechkar prapt kiya ja sakne wala labh nikalta hai. Is labh ko adhikatam karke, aap di gayi stock mulya data ke liye prapt kiya ja sakne wala adhikatam labh nikalte hain.
Vector mein saare mulyo ke saath aavritti karne ke baad, function `maxPro` ko lautata hai, jisme adhikatam labh hota hai jo prapt kiya ja sakta hai.
Mool roop se, yeh code sambhav data ke sath stock kharidne aur bechne se prapt kiya ja sakne wala adhikatam labh nikalne ki samasya ko prabhavit roop se hal karta hai jab aapke paas ek itihasik stock mulya sujhav ki soochi hoti hai.
