Pilas

stack<int> s;
s.push(1);                 // [1]
s.push(13);                // [1, 13]
s.push(7);                 // [1, 13, 7]
cout << s.top() << endl;   // 7
s.pop();                   // [1, 13]
cout << s.size() << endl;  // 2

Stack<Integer> s = new Stack<Integer>();
s.push(1);                     // [1]
s.push(13);                    // [1, 13]
s.push(7);                     // [1, 13, 7]
System.out.println(s.peek());  // 7
s.pop();                       // [1, 13]
System.out.println(s.size());  // 2

stack = []  # []
stack.append(1)  # [1]
stack.append(2)  # [1, 2]
stack.append(3)  # [1, 2, 3]
v = stack[-1]  # stack = [1, 2, 3] (sin cambios), v = 3
stack.pop()  # [1, 2]
v = stack.pop()  # stack = [1], v = 2
stack.append(4)  # [1, 4]
v = stack.pop(0)  # stack = [4], v = 1

#include <bits/stdc++.h>
 
using namespace std;
 
int N;
 
int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
 
	cin >> N;
	stack<pair<int, int>> stack;
	stack.push({0, 0});
 
	for (int i = 1; i <= N; ++i) {
		int a;
		cin >> a;
		while (!stack.empty() && stack.top().first >= a) stack.pop();
		cout << stack.top().second << " ";
		stack.push({a, i});
	}
}

 
/**
 * author: Kai Wang
 */
 
import java.io.*;
import java.util.*;
public class NearestSmallestVals {
 
	/**
	 * Mantenemos una pila de pares (ind, value)
	 * Recorremos el arreglo de izquierda a derecha y usamos ans para guardar
	 * respuestas
	 * Si el valor de a_i > (stk.peek()=a_k) entonces saco el tope de la
	 * pila. Esto está bien porque para todo j>k, a_j>=a_k, o (j,a_j) está en
	 * la pila. Si a_k < a_i entonces fijamos ans[i]=k e insertamos (i,a_i)
	 * Nótese que los elementos de la pila están ordenados por índice
	 *
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		int[] a = new int[N + 1];
		StringTokenizer st = new StringTokenizer(br.readLine());
		for (int i = 1; i <= N; i++) { a[i] = Integer.parseInt(st.nextToken()); }
		Stack<Integer> stk = new Stack<>();
		stk.add(0);
		stk.add(1);
		int[] ans = new int[N + 1];
		ans[1] = 0;
		for (int i = 2; i <= N; i++) {
			while (a[stk.peek()] >= a[i]) { stk.pop(); }
			// stk.peek()<a[i]
			// Esto existe porque a[0]=0 y a[i]>0 para todo i>0
			ans[i] = stk.peek();
			stk.push(i);
		}
		for (int i = 1; i <= N; i++) { System.out.print(ans[i] + " "); }
	}
}

n = int(input())
nums = list(map(int, input().split()))
 
ans = []
stack = []  # guarda (a_i, i)
for idx, num in enumerate(nums):
	while stack and stack[-1][0] >= num:
		stack.pop()
 
	ans.append(0 if not stack else stack[-1][1] + 1)
	stack.append((num, idx))
 
print(*ans)