This article presents an algorithmic problem with practical value for stock market analysis. For instance, suppose you are trading the cryptocurrency Ethereum.

How much profit in dollars can you make by **buying low and selling hi**gh based on historical data?

## Maximum Profit Basic Algorithm

The max profit algorithm calculates the maximum profit you’d obtain by buying low and selling high:

# Profit of a single # buying low and selling high def maximumProfit(A): m = 0 for i in range(0, len(A)): for j in range (i + 1, len(A)): m = max(m, A[j] - A[i]) return m # Ethereum daily prices in Dec 2017 ($) prices = [455, 460, 465, 451, 414, 415, 441] print(maximumProfit(prices)) # 27

**Exercise**: Take a guess–what is the output of this code snippet?

## Maximum Profit Algorithm Description

The function `maximumProfit`

takes an input sequence A, e.g. a week of Ethereum prices in December 2017. It returns the largest profit from buying low and selling high.

*The algorithm works as follows:*

It iterates over all sequence indices `i`

, i.e., the buying points, and over all sequence indices `j>i`

, i.e., the selling points.

For each buying/selling pair `(i,j)`

, it calculates the profit as the difference between the prices at the selling and the buying points, i.e., `A[j]-A[i]`

.

The variable `profit`

maintains the largest possible profit: $27 on $414 invested capital.

π‘ **Algorithmic Complexity**: This implementation has **quadratic runtime complexity** as you have to check *O(n*n)* different combinations of buying and selling points. You’ll learn about a linear-runtime solution later.

## Alternative Maximum Profit Algorithm with Slicing

Here’s a slight variant of the above algorithm:

# Profit of a single # buying low and selling high def maximumProfit(A): m = 0 for i in range(0, len(A)-1): buy, sell = A[i], max(A[i+1:]) m = max(m, sell-buy) return m # Ethereum daily prices in Dec 2017 ($) prices = [455,460,465,451,414,415,441] print(maximumProfit(prices)) # 27

It’s a bit more readable and uses slicing instead of the second nested for loop.

## Maximum Profit Algorithm with Linear Runtime in Python

The following algorithm has **linear runtime complexity** and is much more efficient for a single-sell max-profit algorithm.

def maximumProfit(A): buy, m = 0, 0 for i in range(len(A)): buy = min(buy, A[i]) profit = A[i] - buy m = max(m, profit) return m # Ethereum daily prices in Dec 2017 ($) prices = [455,460,465,451,414,415,441] print(maximumProfit(prices)) # 27

The maximum profit in the above algorithm of buying low and selling high for the list of prices `[455,460,465,451,414,415,441]`

is `27`

.

You buy at $414 and sell at $441 which leads to a profit of $441-$414=$27.

## Maximum Profit Python Puzzle

Before I show you the solution to the max profit example in the code—can you solve this code puzzle on our interactive Python puzzle app?

Click to solve the exercise and test your Python skills!

Are you a master coder? Test your skills now!

## Related Video

Would you enjoy becoming the best Python coders in your environment? Here’s a decision you won’t regret: join my Python email academy. It’s the most comprehensive Python email academy in the world!

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com that has taught exponential skills to millions of coders worldwide. He’s the author of the best-selling programming books Python One-Liners (NoStarch 2020), The Art of Clean Code (NoStarch 2022), and The Book of Dash (NoStarch 2022). Chris also coauthored the Coffee Break Python series of self-published books. He’s a computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.