I joined leet code 30 days of code challenge and this is the 5th challenge. I would like to give some of the insight I found while solving this problem with swift. The problem as follows.

Say you have an array for which the *i*^{th} element is the price of a given stock on day *i*.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).

**Note:** You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

**Note:** You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

**Example 1:**

**Input:** [7,1,5,3,6,4]
**Output:** 7
**Explanation:** Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.

**Example 2:**

**Input:** [1,2,3,4,5]
**Output:** 4
**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
engaging multiple transactions at the same time. You must sell before buying again.

**Example 3:**

**Input:** [7,6,4,3,1]
**Output:** 0
**Explanation:** In this case, no transaction is done, i.e. max profit = 0.

The first approach consist in taking advantage of the moment we find a valley and immediately after take into account its adjacent peak. now we add the difference.

class Solution {
func maxProfit(_ prices: [Int]) -> Int {
if prices.count == 0 {return 0}
var maxProfit: Int = 0
var valley: Int = prices[0]
var peak: Int = prices[0]
var i: Int = 0
print(prices.count)
while i < prices.count - 1{
while i < prices.count - 1 && prices[i] >= prices[i+1]{
i += 1
}
print("this is a valley \(prices[i]) ")
valley = prices[i]
while i < prices.count - 1 && prices[i] < prices[i+1]{
i += 1
}
print("this is a peak \(prices[i])")
peak = prices[i]
maxProfit += peak - valley
}
}

The second solution takes advantage of the fact that the sum of every incremental value can be uses to simulated the highest peak. So the sum of small increment A, B and C are equals to the largest increment to the peak.

class Solution {
func maxProfit(_ prices: [Int]) -> Int {
var diff: Int = 0
if prices.count == 0 || prices.count == 1 {return 0}
for i in 1...prices.count-1{
print(i)
if prices[i] > prices[i-1]{
diff += prices[i] - prices[i-1]
}
}
return diff
}
}

### Like this:

Like Loading...