Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Maximum Profit

You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.

Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .

Input

The first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.

Output

Print the maximum value in a line.

Constraints

$2 \leq n \leq 200,000$

$1 \leq R_t \leq 10^9$

Sample Input 1

6
5
3
1
3
4
3

Sample Output 1

3

Sample Input 2

3
4
3
2

Sample Output 2

-1

Solution in Rust (judge verdict: Accepted)

/* ALDS1_1_D: Maximum Profit - http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_1_D
 
Maximum Profit
You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.

Write a program which reads values of a currency Rt at a certain time t (t=0,1,2,...n−1), and reports the maximum value of Rj−Ri where j>i .

Input
The first line contains an integer n. In the following n lines, Rt (t=0,1,2,...n−1) are given in order.

Output
Print the maximum value in a line.

Constraints
2≤n≤200,000
1≤Rt≤109
Sample Input 1
6
5
3
1
3
4
3
Sample Output 1
3
Sample Input 2
3
4
3
2
Sample Output 2
-1
*/

use std::io::*;
 
fn main() {
    let stdin = stdin();
    let mut lines = stdin.lock().lines().map(|l| l.unwrap());

    let n = lines.next().unwrap().parse().unwrap();
    let mut R = lines.take(n).map(|s| s.parse::<i32>().unwrap());

    // It would be good if we could just take max - min, but there is the
    // possibility that min comes after max... so we should consider both
    // the absolute max and min and the current one (which are candidates
    // for appearing in the final answer).
    // Notice that we do not use the absolute max, but calculate it for
    // completeness.
    let mut min;
    let mut max;
    let mut current_max;
    let mut current_min;

    let a = R.next().unwrap();
    let b = R.next().unwrap();
    current_max = b; current_min = a;
    if a > b { 
        min = b; max = a;
    } else {
        max = b; min = a;
    }
    
    for r in R {
        if r - min > current_max - current_min {
            current_max = r;
            current_min = min;
        }
        if r > max { max = r }
        if r < min { min = r }
    }

    let ans = current_max - current_min;
    println!("{}", ans);
}

// ------------------------------------------------------------------
// Auxiliary methods.
fn array_to_str(arr: &Vec<i32>) -> String {
    // Converts a numerical array to a string for output purposes.
    let mut ans = String::new();
    for a in arr {
        ans.push_str(&format!("{} ", *a));
    }
    return ans.trim().to_string();
}