Minimum Loss

                            Solution in C :

In   C++  :






#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for (int i = (a); i <= (b); ++i)
#define REPD(i,a,b) for (int i = (a); i >= (b); --i)
#define FORI(i,n) REP(i,1,n)
#define FOR(i,n) REP(i,0,int(n)-1)
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define ll long long
#define SZ(x) int((x).size())
#define DBG(v) cerr << #v << " = " << (v) << endl;
#define FOREACH(i,t) for (typeof(t.begin()) i=t.begin(); i!=t.end(); i++)
#define fi first
#define se second

int n;
ll a[200200];

int main() {
    scanf("%d", &n);
    FOR(i,n) scanf("%lld", &a[i]);
    set<ll> s;
    long long res = 1000000000000000000LL;
    FOR(i,n) {
        auto it = s.lower_bound(a[i]);
        if (it != s.end()) {
            res = min(res, *it-a[i]);
        }
        s.insert(a[i]);
    }
    printf("%lld\n", res);
    return 0;
}










In  Java  :









import java.util.*;


public class Main{

	public static void main(String[] args){
		Scanner input=new Scanner(System.in);


		int n=input.nextInt();
		
		ArrayList<Long> p=new ArrayList();
		
		for(int i=1;i<=n;i++)
			p.add(input.nextLong());
		
		
		long minLoss=Integer.MAX_VALUE;
		
		ArrayList<Long> p2=(ArrayList<Long>)p.clone();
		
		Collections.sort(p2);

		
		for(int i=n-1;i>0;i--){
			long a=p2.get(i);
			long b=p2.get(i-1);
			if(a-b<minLoss && p.indexOf(a)<p.indexOf(b))
				minLoss=a-b;
		}
		
		System.out.println(minLoss);
			
	}
}









In   C  :







#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef long long ll;

typedef struct treap {
    ll v;
    int p;
    struct treap *l, *r;
}* Treap;

Treap newNode(ll v) {
    Treap t = (Treap) malloc (sizeof (struct treap));
    t->v = v;
    t->p = (rand() << 15) | rand();
    t->l = t->r = NULL;
    return t;
}

Treap merge(Treap l, Treap r) {
    if (!l)
        return r;
    if (!r)
        return l;
    if (l->p > r->p) {
        l->r = merge(l->r, r);
        return l;
    }
    r->l = merge(l, r->l);
    return r;
}

void split(Treap root, Treap *l, Treap *r, ll v) {
    if (!root) {
        *l = *r = NULL;
        return;
    }
    if (root->v <= v) {
        split(root->r, &(root->r), r, v);
        *l = root;
    }
    else {
        split(root->l, l, &(root->l), v);
        *r = root;
    }
}

Treap first(Treap root) {
    while (root->l)
        root = root->l;
    return root;
}

Treap last(Treap root) {
    while (root->r)
        root = root->r;
    return root;
}

int main() {
    srand(time(NULL));
    int n;
    ll mx = 0, mn = 1000000000000000000LL, p;
    Treap root = NULL, t, l, r;
    scanf("%d", &n);
    while (n--) {
        scanf("%lld", &p);
        if (p < mx) {
            split(root, &l, &r, p);
            t = first(r);
            if ((t->v - p) < mn)
                mn = t->v - p;
            if (!l || last(l)->v != p) {
                t = newNode(p);
                root = merge(l, t);
                root = merge(root, r);
            }
        }
        else if (p > mx) {
            mx = p;
            t = newNode(p);
            root = merge(root, t);
        }
    }
    printf("%lld", mn);
    return 0;
}










In  Python3 :







n=int(input())

l = [int(item) for item in input().split()]
l2 = l.copy()
d={}
for i in range(len(l)):
    d[l[i]] = i
l = sorted(l)
m = float("inf")
for i in range(len(l)-1):
    if d[l[i+1]] < d[l[i]] : m = min(m,l[i + 1] - l[i])
print(m)