public static int minimumLoss(List<Long> price) {
    // Create a sorted copy of the prices list
    List<Long> sorted = new ArrayList<>(price);
    Collections.sort(sorted);

    // Map to store the original index of each price
    HashMap<Long, Integer> IndexMap = new HashMap<>();
    for (int i = 0; i < price.size(); i++) {
      IndexMap.put(price.get(i), i);
    }

    long minLoss = Long.MAX_VALUE;

    // Iterate through the sorted prices to calculate the minimum loss
    for (int i = 0; i < sorted.size() - 1; i++) {
      Long next = sorted.get(i + 1);
      Long current = sorted.get(i);
      // Check if the "next" price comes after the "current" price in the
      // original list
      if (next - current < minLoss
          && IndexMap.get(next) < IndexMap.get(current)) {
        minLoss = next - current;
      }
    }

    return (int) minLoss;
  }
}

  }
}

def minimumLoss(price):
    arr = sorted(enumerate(price), key=lambda x: x[1], reverse=True)
    diff = [arr[i][1] - arr[i + 1][1] for i in range(len(arr) - 1) if arr[i][0] < arr[i + 1][0]]
    return max(min(diff), 0)

int minimumLoss(std::vector<long> price) {
	std::set<long> before;
	long minLoss = LONG_MAX;
	for (long p : price)
	{
		long nearestGreater = *before.upper_bound(p);
		long loss = nearestGreater - p;
		if (loss > 0 && loss < minLoss)
			minLoss = loss;

		before.insert(p);
	}

	return minLoss;
}