Master Stacks - LIFO Data Structure

class Stack:
    def __init__(self, capacity=100):
        self.items = []
        self.capacity = capacity

    def push(self, value):
        if len(self.items) >= self.capacity:
            raise Exception("Stack Overflow")
        self.items.append(value)
        return True

    def pop(self):
        if self.is_empty():
            raise Exception("Stack Underflow")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise Exception("Stack is empty")
        return self.items[-1]

    def is_empty(self):
        return len(self.items) == 0

    def size(self):
        return len(self.items)

# Usage
stack = Stack()
stack.push(10)
stack.push(20)
stack.push(30)
print(stack.peek())  # Output: 30
print(stack.pop())   # Output: 30
print(stack.size())  # Output: 2

class Stack {
    constructor(capacity = 100) {
        this.items = [];
        this.capacity = capacity;
    }

    push(value) {
        if (this.items.length >= this.capacity) {
            throw new Error("Stack Overflow");
        }
        this.items.push(value);
        return true;
    }

    pop() {
        if (this.isEmpty()) {
            throw new Error("Stack Underflow");
        }
        return this.items.pop();
    }

    peek() {
        if (this.isEmpty()) {
            throw new Error("Stack is empty");
        }
        return this.items[this.items.length - 1];
    }

    isEmpty() {
        return this.items.length === 0;
    }

    size() {
        return this.items.length;
    }
}

// Usage
const stack = new Stack();
stack.push(10);
stack.push(20);
stack.push(30);
console.log(stack.peek());  // Output: 30
console.log(stack.pop());   // Output: 30
console.log(stack.size());  // Output: 2

package main

import "errors"

type Stack struct {
    items    []int
    capacity int
}

func NewStack(capacity int) *Stack {
    return &Stack{
        items:    make([]int, 0, capacity),
        capacity: capacity,
    }
}

func (s *Stack) Push(value int) error {
    if len(s.items) >= s.capacity {
        return errors.New("stack overflow")
    }
    s.items = append(s.items, value)
    return nil
}

func (s *Stack) Pop() (int, error) {
    if s.IsEmpty() {
        return 0, errors.New("stack underflow")
    }
    index := len(s.items) - 1
    value := s.items[index]
    s.items = s.items[:index]
    return value, nil
}

func (s *Stack) Peek() (int, error) {
    if s.IsEmpty() {
        return 0, errors.New("stack is empty")
    }
    return s.items[len(s.items)-1], nil
}

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func (s *Stack) Size() int {
    return len(s.items)
}

public class Stack {
    private int[] items;
    private int top;
    private int capacity;

    public Stack(int capacity) {
        this.items = new int[capacity];
        this.capacity = capacity;
        this.top = -1;
    }

    public void push(int value) {
        if (top >= capacity - 1) {
            throw new RuntimeException("Stack Overflow");
        }
        items[++top] = value;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("Stack Underflow");
        }
        return items[top--];
    }

    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return items[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public int size() {
        return top + 1;
    }
}

#include <vector>
#include <stdexcept>

class Stack {
private:
    std::vector<int> items;
    int capacity;

public:
    Stack(int cap = 100) : capacity(cap) {}

    void push(int value) {
        if (items.size() >= capacity) {
            throw std::overflow_error("Stack Overflow");
        }
        items.push_back(value);
    }

    int pop() {
        if (isEmpty()) {
            throw std::underflow_error("Stack Underflow");
        }
        int value = items.back();
        items.pop_back();
        return value;
    }

    int peek() {
        if (isEmpty()) {
            throw std::runtime_error("Stack is empty");
        }
        return items.back();
    }

    bool isEmpty() {
        return items.empty();
    }

    size_t size() {
        return items.size();
    }
};

pub struct Stack {
    items: Vec<i32>,
    capacity: usize,
}

impl Stack {
    pub fn new(capacity: usize) -> Self {
        Stack {
            items: Vec::with_capacity(capacity),
            capacity,
        }
    }

    pub fn push(&mut self, value: i32) -> Result<(), &'static str> {
        if self.items.len() >= self.capacity {
            return Err("Stack Overflow");
        }
        self.items.push(value);
        Ok(())
    }

    pub fn pop(&mut self) -> Option<i32> {
        self.items.pop()
    }

    pub fn peek(&self) -> Option<&i32> {
        self.items.last()
    }

    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    pub fn size(&self) -> usize {
        self.items.len()
    }
}