Value stream

public class Losses: SequenceType {
    private var source: Generator?;

    public typealias Generator = AnyGenerator<Int>

    init <S: SequenceType where S.Generator.Element == Int>(_ _source: S) {
        source = Generator(_source.generate())
    }

    public func generate() -> Generator {
        var peak: Int = -1
        var trough: Int = -1

        return AnyGenerator {
            if let source = self.source {
                while let v = source.next() {
                    if v > peak {
                        let loss = trough - peak
                        peak = v
                        trough = peak
                        if loss < 0 {
                            return loss
                        }
                        continue
                    }
                    if v < trough { trough = v }
                }
                self.source = nil
                return trough - peak
            } else {
                return nil
            }
        }
    }
}

let n = Int(readLine()!)!
var input = (readLine()!).characters.split{$0 == " "}
var lossSeq = Losses(input.map { return Int(String($0)) })
var minimum = minElement(lossSeq)
print(minimum)