Design a Stack With Increment Operation solution and explanation

class CustomStack:
    def __init__(self, maxSize: int):
        self.stack = []
        self.maxSize = maxSize

    def push(self, x: int) -> None:
        if len(self.stack) < self.maxSize:
            self.stack.append(x)

    def pop(self) -> int:
        if len(self.stack) == 0:
            return -1
        return self.stack.pop()

    def increment(self, k: int, val: int) -> None:
        for i in range(min(k, len(self.stack))):
            self.stack[i] += val

class CustomStack {
    constructor(maxSize) {
        this.stack = [];
        this.maxSize = maxSize;
    }

    push(x) {
        if (this.stack.length < this.maxSize) {
            this.stack.push(x);
        }
    }

    pop() {
        if (this.stack.length === 0) {
            return -1;
        }
        return this.stack.pop();
    }

    increment(k, val) {
        for (let i = 0; i < Math.min(k, this.stack.length); i++) {
            this.stack[i] += val;
        }
    }
}

class CustomStack {
    private int[] stack;
    private int[] increment;
    private int top;

    public CustomStack(int maxSize) {
        stack = new int[maxSize];
        increment = new int[maxSize];
        top = 0;
    }

    public void push(int x) {
        if (top < stack.length) {
            stack[top++] = x;
        }
    }

    public int pop() {
        if (top == 0) return -1;
        int index = --top;
        int ret = stack[index] + increment[index];
        if (index > 0) increment[index - 1] += increment[index];
        increment[index] = 0;
        return ret;
    }

    public void increment(int k, int val) {
        int i = Math.min(k, top) - 1;
        if (i >= 0) increment[i] += val;
    }
}

#include <vector>

class CustomStack {
    std::vector<int> stack;
    std::vector<int> increment;
    int maxSize;

public:
    CustomStack(int maxSize) : maxSize(maxSize) {
        increment.resize(maxSize, 0);
    }

    void push(int x) {
        if (stack.size() < maxSize) {
            stack.push_back(x);
        }
    }

    int pop() {
        int idx = stack.size() - 1;
        if (idx < 0) return -1;

        int result = stack[idx] + increment[idx];
        if (idx > 0) increment[idx - 1] += increment[idx];
        increment[idx] = 0;
        stack.pop_back();
        return result;
    }

    void increment(int k, int val) {
        int i = std::min(k, (int)stack.size()) - 1;
        if (i >= 0) increment[i] += val;
    }
};

class CustomStack {
    private stk: number[];
    private add: number[];
    private i: number;

    constructor(maxSize: number) {
        this.stk = Array(maxSize).fill(0);
        this.add = Array(maxSize).fill(0);
        this.i = 0;
    }

    push(x: number): void {
        if (this.i < this.stk.length) {
            this.stk[this.i++] = x;
        }
    }

    pop(): number {
        if (this.i <= 0) {
            return -1;
        }
        const ans = this.stk[--this.i] + this.add[this.i];
        if (this.i > 0) {
            this.add[this.i - 1] += this.add[this.i];
        }
        this.add[this.i] = 0;
        return ans;
    }

    increment(k: number, val: number): void {
        if (this.i > 0) {
            this.add[Math.min(this.i, k) - 1] += val;
        }
    }
}

/**
 * Your CustomStack object will be instantiated and called as such:
 * var obj = new CustomStack(maxSize)
 * obj.push(x)
 * var param_2 = obj.pop()
 * obj.increment(k,val)
 */

type CustomStack struct {
	stk []int
	add []int
	i   int
}

func Constructor(maxSize int) CustomStack {
	return CustomStack{make([]int, maxSize), make([]int, maxSize), 0}
}

func (this *CustomStack) Push(x int) {
	if this.i < len(this.stk) {
		this.stk[this.i] = x
		this.i++
	}
}

func (this *CustomStack) Pop() int {
	if this.i <= 0 {
		return -1
	}
	this.i--
	ans := this.stk[this.i] + this.add[this.i]
	if this.i > 0 {
		this.add[this.i-1] += this.add[this.i]
	}
	this.add[this.i] = 0
	return ans
}

func (this *CustomStack) Increment(k int, val int) {
	if this.i > 0 {
		this.add[min(k, this.i)-1] += val
	}
}

/**
 * Your CustomStack object will be instantiated and called as such:
 * obj := Constructor(maxSize);
 * obj.Push(x);
 * param_2 := obj.Pop();
 * obj.Increment(k,val);
 */