ટ્રાંઝેક્શન ફી લીટકોડ સોલ્યુશન સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમય


મુશ્કેલી સ્તર મધ્યમ
વારંવાર પૂછવામાં આવે છે એમેઝોન
અરે ડાયનેમિક પ્રોગ્રામિંગ લોભી

સમસ્યા નિવેદન

ટ્રાન્ઝેક્શન ફી સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમય, સમસ્યામાં અમને એરે આપવામાં આવે છે જ્યાં એરેના દરેક ઘટકમાં તે દિવસે આપેલા સ્ટોકની કિંમત હોય છે.

ની વ્યાખ્યા વ્યવહાર શેરનો એક હિસ્સો ખરીદે છે અને તે શેરનો એક શેર વેચે છે.

અમારું કાર્ય નીચેના નિયંત્રણો હેઠળ મહત્તમ નફો શોધવાનું છે:

  1. જો આપણે પહેલાનો સ્ટોક વેચ્યો ન હોય તો અમે નવો સ્ટોક ખરીદી શકતા નથી. તે એક સમયે અમારી પાસે એક સ્ટોક હોઈ શકે છે.
  2. આપણે બહુવિધ વ્યવહાર કરી શકીએ છીએ.
  3. દરેક વખતે જ્યારે આપણે કોઈ ટ્રાંઝેક્શન કરીશું ત્યારે અમને ટ્રાંઝેક્શન ફી ભરવાની જરૂર છે.
  4. એક સમયે આપણે એક કરતા વધારે શેર ખરીદી શકતા નથી.

ઉદાહરણ

prices = [1, 3, 2, 8, 4, 9], fee=2
8

સમજૂતી: મહત્તમ નફો જે મેળવી શકાય છે તે 8 છે. વ્યવહારની વિગત નીચે મુજબ છે:

ટ્રાંઝેક્શન ફી લીટકોડ સોલ્યુશન સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમય

ટ્રાન્ઝેક્શન ફી લીટકોડ સોલ્યુશન સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમયનો અભિગમ

આ સમસ્યાનું સમાધાન લાવવા માટે આપણે સ્ટોકની ખરીદી અને વેચાણ દ્વારા નફો કેવી રીતે વધારી શકીએ તે વિશે વિચારવાની જરૂર છે. મહત્તમ લાભ મેળવવા માટેની આ રીતો છે:

  1. અમે સ્ટોકને ન્યૂનતમ ભાવે ખરીદીશું અને મહત્તમ ભાવે વેચીશું.
  2. આપણે દરેક વ્યવહાર માટે ફી ચૂકવવાની જરૂર હોવાથી, વેચાણની કિંમત> કિંમત કિંમત + ફી ત્યારે જ અમે સ્ટોકનું વેચાણ કરીશું.
  3. શ્રેષ્ઠ વેચાણ કિંમત શોધી રહ્યા હોવા છતાં, જ્યારે અમે વેચાણ કિંમત> કિંમત કિંમત + ફીનો સામનો કરીશું ત્યારે અમે સ્ટોક વેચીશું. પછી કિંમત કિંમત કિંમત કિંમત બનશે- ફી.

અમલીકરણ

ટ્રાન્ઝેક્શન ફી સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમય માટે સી ++ કોડ

//function to find maximum profit
#include <bits/stdc++.h> 
using namespace std; 
    int Profit(vector<int>& prices, int fee) {
        int n = prices.size();
        int ans = 0;
        int mn = prices[0];
        for(int i=0;i<n;i++)
        {
         if (prices[i] < mn)
                mn = prices[i];
         if(prices[i] > mn + fee)
         {
              ans += prices[i] - fee - mn;
              mn = prices[i] - fee;
         }
            
        }
           return ans;  
    }

int main() 
{ 
 vector<int> arr = {1, 3, 2, 8, 4, 9}; 
 int fee=2;
 cout<<Profit(arr,fee)<<endl; 
 return 0;
}
8

ટ્રાંઝેક્શન ફી સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમય માટેનો જાવા કોડ

import java.util.Arrays; 
public class Tutorialcup {
 public static  int maxProfit(int[] prices, int fee) {
        int n = prices.length;
        int ans = 0;
        int mn = prices[0];
        for(int i=0;i<n;i++)
        {
         if (prices[i] < mn)
                mn = prices[i];
         if(prices[i] > mn + fee)
         {
              ans += prices[i] - fee - mn;
              mn = prices[i] - fee;
         }
            
        }
           return ans;  
    }
  public static void main(String[] args) {
    int [] arr = {1, 3, 2, 8, 4, 9}; 
    int fee=2;
    int ans=  maxProfit(arr,fee);
    System.out.println(ans);
  }
}
8

ટ્રાન્ઝેક્શન ફી લીટકોડ સોલ્યુશન સાથે સ્ટોક ખરીદવા અને વેચવાનો શ્રેષ્ઠ સમયનું જટિલતા વિશ્લેષણ

સમયની જટિલતા

ઉપરોક્ત કોડની સમય જટિલતા છે ઓ (એન) કારણ કે અમે ફક્ત એક જ વાર ભાવના એરેને વટાવીએ છીએ. અહીં n એ એરેની લંબાઈ છે.

જગ્યાની જટિલતા

ઓ (1) કારણ કે આપણે ફક્ત જવાબ સ્ટોર કરવા માટે મેમરીનો ઉપયોગ કરીએ છીએ.

સંદર્ભ