package main

import (
	"fmt"
)

type MinStackOld struct {
	val []int
	min []int
	top int
}

/** initialize your data structure here. */
func ConstructorOld() MinStackOld {
	s := MinStackOld{make([]int, 0), make([]int, 0), -1}
	return s
}

func (this *MinStackOld) Push(x int) {
	this.val = append(this.val, x)
	this.top++
	idx := 0
	for ; idx < this.top; idx++ {
		if x > this.val[idx] {
			break
		}
	}
	this.min = append(this.min, 0)
	copy(this.min[idx+1:this.top+1], this.min[idx:this.top])
	this.min[idx] = x
}

func (this *MinStackOld) Pop() {
	if this.top != -1 {
		idx := 0
		for ; idx < this.top+1; idx++ {
			if this.min[idx] == this.val[this.top] {
				break
			}
		}
		this.min = append(this.min[:idx], this.min[idx+1:]...)
		this.val = this.val[:this.top]
		this.top--
	}
}

func (this *MinStackOld) Top() int {
	return this.val[this.top]
}

func (this *MinStackOld) GetMin() int {
	return this.min[this.top]
}

/**
 * Your MinStack object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Push(x);
 * obj.Pop();
 * param_3 := obj.Top();
 * param_4 := obj.GetMin();
 */

type MinStack struct {
	val []int
	min []int
}

/** initialize your data structure here. */
func Constructor() MinStack {
	return MinStack{}
}

// important! min []int stores the "current miximum"
func (this *MinStack) Push(x int) {
	this.val = append(this.val, x)
	if len(this.min) == 0 {
		this.min = append(this.min, x)
		return
	}
	m := this.min[len(this.min)-1]
	if x < m {
		this.min = append(this.min, x)
		return
	}
	this.min = append(this.min, m)
}

func (this *MinStack) Pop() {
	n := len(this.val) - 1
	this.val = this.val[:n]
	this.min = this.min[:n]
}

func (this *MinStack) Top() int {
	return this.val[len(this.val)-1]
}

func (this *MinStack) GetMin() int {
	return this.min[len(this.min)-1]
}

func main() {
	stack := Constructor()
	stack.Push(1)
	fmt.Println(stack.Top())
	fmt.Println(stack.GetMin())
}