def minimumLoss(price):
    # Thinking process:
    # 1 Brutal force (n^2)
    # 2 Greedy apporach.(nlogn)
    # Think about insertion sort. But don't use insertion sort
    # in one step, after we insert from the current position
    # to a previously sorted subarray, 
    # for our question,we only need to
    # compare the current number to the previous number of its inserted pos.
    # example: input=[5,10,3,4]
    # insertion sort step 2 
    # subarray is [10,5] (sort from big to small)
    # we inserted 3, subarray becomes [10,5,3]. For our question we only need to compare 3 with 5
    # if there is incoming number such as 4 we only need to compare with
    # inserted pos([10,5,4,3], insert 4) which is also 5, we don't need to care 
    # about 3, otherwise we will get a positive loss.
    # after the sort complete, we get our min reslut, and the result must be come from a
    # sorted array, between a number and its left neighbour.
    # In conclusion, we only need to compare the neighbour 
    # in an sorted array and we don't 
    # need to use the insertion sort.
    #
    # question to ask:
    # Does 0 count as a valid loss?
    idx2Price=collections.defaultdict(list)
    for idx,p in enumerate(price):
        idx2Price[p].append(idx)
        if len(idx2Price[p])>1:
            return 0
    
    n=len(price)
    res=math.inf
    price.sort(reverse=True)
    for i in range(1,n):
        if idx2Price[price[i]]>idx2Price[price[i-1]]:
            res=min(res,price[i-1]-price[i])
    
    return res

    ArrayList<Long> newarr=new ArrayList<>(price);
    Collections.sort(price);
        long min=Long.MAX_VALUE;
        for(int i=0;i<newarr.size()-1;i++)
        {
            int k=Collections.binarySearch(price, newarr.get(i));
            if(k==0)
            {
                price.remove(k);
                continue;
            }
            long min_l=(price.get(k)-price.get(k-1));
            if(min_l<min)
            {
                min=min_l;
            }
            price.remove(k);
        }          
        return min;

int minimumLoss(vector<long> price) {
  long min = -1;
  multiset<long> p(price.begin(), price.end()); // sort by price
  for (string::size_type i(0); i<price.size()-1; ++i) {
    auto it = p.find(price[i]); // find current price in set
    while (it!=p.begin() && *it==price[i]) --it; // find next lower price (mutimap -> while)
    if (*it<price[i] && (price[i]-*it<min||min==-1)) min=price[i]-*it;
    p.erase(price[i]); // remove current price
  }
  return min;
}

int minimumLoss(vector<long> price) {
    long n=price.size();
    int mini=INT_MAX;
    vector <long> prs;
    for(int i=0;i<n;i++){
        prs.push_back(price[i]);
    }
    sort(prs.begin(),prs.end());
    for(int i=0;i<n;i++){
        int l=1;
        int mid;
        int h=prs.size()-1;
        while(l<=h){
            mid=(l+h)/2;
            if(price[i]==prs[mid]){
                long x=prs[mid]-prs[mid-1];
                if(mini>x){
                    mini=x;
                }
                prs.erase(prs.begin()+mid);
                break;
            }
            else if(price[i]<prs[mid]){
                   h=mid-1; 
               }
            else{
                  l=mid+1;
               }
            }
        }
        return mini;
}