Add files via upload

Author: je-suis-tm

stock trading dynamic programming.jl

@@ -0,0 +1,77 @@
+
+#a simple day trading game
+#day trader is only allowed to make at maximum two trades
+#the strategy is long only
+#lets find out the maximum profit
+
+#more details can be found in the following link
+# https://www.geeksforgeeks.org/maximum-profit-by-buying-and-selling-a-share-at-most-twice/
+
+#an alternative version in recursion exists
+#its done by using a different approach
+#strongly recommend you to take a look
+# https://github.com/je-suis-tm/recursion-and-dynamic-programming/blob/master/stock%20trading%20recursion.jl
+
+#there are two scenarios to maximize the profit
+#one trade or two trades
+#first we run a reverse iteration
+#to obtain the maximum profit from one trade
+#then we run a normal iteration
+#to obtain the maximum profit
+#from one trade plus the result from reverse iteration
+function stock_trading(prices)
+    
+    #initialize the profit at zero
+    profit=[0 for _ in 1:length(prices)]
+    
+    #initialize maximum price with the close price
+    max_price=prices[end]
+    
+    #reverse order iteration
+    for i in length(prices)-1:-1:1
+        
+        #update the maximum price to compute the maximum profit
+        if prices[i]>max_price
+            
+            max_price=prices[i]
+            
+        end
+        
+        #two scenarios to get the maximum profit
+        #either the previous iteration is larger
+        #or this round of iteration
+        profit[i]=max(profit[i+1],max_price-prices[i])
+        
+    end
+    
+    #initialize minimum price with the open price
+    min_price=prices[1]
+    
+    #second round of iteration
+    for i in 2:length(prices)
+        
+        #update the minimum price to compute the maximum profit
+        if prices[i]<min_price
+            
+            min_price=prices[i]
+            
+        end
+        
+        #two scenarios to get the maximum profit
+        #either the previous iteration is larger
+        #or this round of iteration plus the result from single transaction
+        profit[i]=max(profit[i-1],profit[i]+prices[i]-min_price)   
+                
+    end
+    
+    return profit[end]
+    
+end
+
+stock_trading([10,22,5,75,65,80])
+
+stock_trading([2,30,15,10,8,25,80])
+
+stock_trading([100,30,15,10,8,25,80])
+
+stock_trading([90,70,35,11,5])

stock trading dynamic programming.py

@@ -0,0 +1,93 @@
+
+# coding: utf-8
+
+# In[1]:
+
+
+#a simple day trading game
+#day trader is only allowed to make at maximum two trades
+#the strategy is long only
+#lets find out the maximum profit
+
+#more details can be found in the following link
+# https://www.geeksforgeeks.org/maximum-profit-by-buying-and-selling-a-share-at-most-twice/
+
+#an alternative version in recursion exists
+#its done by using a different approach
+#strongly recommend you to take a look
+# https://github.com/je-suis-tm/recursion-and-dynamic-programming/blob/master/stock%20trading%20recursion.py
+
+
+# In[2]:
+
+
+#there are two scenarios to maximize the profit
+#one trade or two trades
+#first we run a reverse iteration
+#to obtain the maximum profit from one trade
+#then we run a normal iteration
+#to obtain the maximum profit
+#from one trade plus the result from reverse iteration
+def stock_trading(prices):
+    
+    #initialize the profit at zero
+    profit=[0 for _ in range(len(prices))]
+    
+    #initialize maximum price with the close price
+    max_price=prices[-1]
+    
+    #reverse order iteration
+    for i in range(len(prices)-2,-1,-1):
+        
+        #update the maximum price to compute the maximum profit
+        if prices[i]>max_price:
+            
+            max_price=prices[i]            
+                
+        #two scenarios to get the maximum profit
+        #either the previous iteration is larger
+        #or this round of iteration
+        profit[i]=max(profit[i+1],max_price-prices[i])        
+        
+    #initialize minimum price with the open price
+    min_price=prices[0]
+    
+    #second round of iteration
+    for i in range(1,len(prices)):
+        
+        #update the minimum price to compute the maximum profit
+        if prices[i]<min_price:
+            
+            min_price=prices[i]
+        
+        #two scenarios to get the maximum profit
+        #either the previous iteration is larger
+        #or this round of iteration plus the result from single transaction
+        profit[i]=max(profit[i-1],profit[i]+prices[i]-min_price)    
+    
+    return profit[-1]
+
+
+# In[3]:
+
+
+stock_trading([10,22,5,75,65,80])
+
+
+# In[4]:
+
+
+stock_trading([2,30,15,10,8,25,80])
+
+
+# In[5]:
+
+
+stock_trading([100,30,15,10,8,25,80])
+
+
+# In[6]:
+
+
+stock_trading([90,70,35,11,5])
+

stock trading recursion.jl

@@ -0,0 +1,106 @@
+
+#a simple day trading game
+#day trader is only allowed to make at maximum two trades
+#the strategy is long only
+#lets find out the maximum profit
+
+#more details can be found in the following link
+# https://www.geeksforgeeks.org/maximum-profit-by-buying-and-selling-a-share-at-most-twice/
+
+#an alternative version in dynamic programming exists
+#its done by using a different approach
+#strongly recommend you to take a look
+# https://github.com/je-suis-tm/recursion-and-dynamic-programming/blob/master/stock%20trading%20dynamic%20programming.jl
+
+#compute the maximum profit for long only strategy
+function compute_profit(prices)
+    
+    #initialize maximum price with the close price
+    max_price=prices[end]
+    
+    #initialize minimum price with the open price
+    min_price=prices[1]
+    
+    #initialize indices
+    left=1
+    right=length(prices)
+    minind=1
+    maxind=length(prices)
+    
+    #we have two indices moving at the same time
+    #one from left to find the minimum value
+    #the other from right to find the maximum value
+    #we are not looking for global minimum
+    #we only want local minimum before the global maximum
+    while left<maxind && right>minind
+        
+        #when a larger value is found
+        #update accordingly
+        if prices[right]>max_price
+
+            max_price=prices[right]
+            maxind=copy(right)
+
+        end
+    
+        #the same applies to a smaller value
+        if prices[left]<min_price
+
+            min_price=prices[left]
+            minind=copy(left)
+
+        end    
+        
+        left+=1
+        right-=1
+        
+    end
+    
+    #maximum profit
+    profit=max_price-min_price
+    
+    #when we lose money
+    #abort the trade
+    if profit<0
+        
+        profit=0
+        
+    end
+    
+    return profit
+    
+end
+
+#there are two scenarios to maximize the profit
+#one trade or two trades
+#since we can execute two transactions
+#we split the array at an iterating index i into half
+#we find out the maximum profit we can obtain from both halves
+function stock_trading(prices,ind)
+    
+    #prevent index error
+    if ind+1==length(prices)
+        
+        return 0
+        
+    end
+    
+    #split
+    upper=prices[1:ind]
+    lower=prices[ind+1:end]
+    
+    #compute profit
+    profit=compute_profit(lower)+compute_profit(upper)
+    
+    #compare recursively
+    return max(profit,stock_trading(prices,ind+1))
+    
+end
+
+stock_trading([10,22,5,75,65,80],1)
+
+stock_trading([2,30,15,10,8,25,80],1)
+
+stock_trading([100,30,15,10,8,25,80],1)
+
+stock_trading([90,70,35,11,5],1)