import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // Создание вектора с начальной емкостью 10
        Vector<String> vector = new Vector<>(10);

        // Добавление элементов
        vector.add("Element 1");
        vector.add("Element 2");
        vector.add("Element 3");

        // Чтение элементов
        System.out.println("Element at index 1: " + vector.get(1));

        // Удаление элемента
        vector.remove(2);

        // Итерация по элементам
        for (String element : vector) {
            System.out.println("Element: " + element);
        }
    }
}

import java.util.Vector;

public class VectorChallenge {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();
        vector.add(15);
        vector.add(30);
        vector.add(45);
        vector.add(60);
        vector.add(75);

        // Iterate and modify
        for (int i = 0; i < vector.size(); i++) {
            if (vector.get(i) % 30 == 0) {
                vector.set(i, vector.get(i) / 2);
            }
        }

        // Add new elements
        vector.add(10);
        vector.add(20);

        int sum = 0;
        for (int num : vector) {
            sum += num;
        }

        System.out.println("Sum: " + sum);
    }
}

Vector<String> vector = new Vector<>();
vector.add("Element 1");

vector.add(1, "Element 2");

String element = vector.get(0);

int size = vector.size();

vector.remove("Element 1");

vector.remove(0);

Enumeration<String> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
    System.out.println("Element: " + enumeration.nextElement());
}

Iterator<String> iterator = vector.iterator();
while (iterator.hasNext()) {
    System.out.println("Element: " + iterator.next());
}

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // Добавление элементов в стек
        stack.push("Element 1");
        stack.push("Element 2");
        stack.push("Element 3");

        // Чтение верхнего элемента стека без его удаления
        System.out.println("Top element: " + stack.peek());

        // Удаление верхнего элемента стека
        System.out.println("Popped element: " + stack.pop());

        // Чтение элементов после удаления
        System.out.println("Top element after pop: " + stack.peek());
    }
}

public static String reverseString(String input) {
    Stack<Character> stack = new Stack<>();
    for (char c : input.toCharArray()) {
        stack.push(c);
    }
    StringBuilder reversed = new StringBuilder();
    while (!stack.isEmpty()) {
        reversed.append(stack.pop());
    }
    return reversed.toString();
}

public static boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '{' || c == '[') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

public static String infixToPostfix(String expression) {
    Stack<Character> stack = new Stack<>();
    StringBuilder result = new StringBuilder();
    for (char c : expression.toCharArray()) {
        if (Character.isLetterOrDigit(c)) {
            result.append(c);
        } else if (c == '(') {
            stack.push(c);
        } else if (c == ')') {
            while (!stack.isEmpty() && stack.peek() != '(') {
                result.append(stack.pop());
            }
            stack.pop();
        } else {
            while (!stack.isEmpty() && precedence(c) <= precedence(stack.peek())) {
                result.append(stack.pop());
            }
            stack.push(c);
        }
    }
    while (!stack.isEmpty()) {
        result.append(stack.pop());
    }
    return result.toString();
}

public static int precedence(char ch) {
    switch (ch) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '^':
            return 3;
    }
    return -1;
}

import java.util.Stack;

public class StackChallenge {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.push(40);
        stack.push(50);

        int sum = 0;

        while (!stack.isEmpty()) {
            int value = stack.pop();
            if (value % 20 == 0) {
                stack.push(value / 2);
            } else {
                sum += value;
            }
        }

        System.out.println("Sum: " + sum);
    }
}

public class Stack<E> extends Vector<E> {
    public Stack() {
    }

    public E push(E item) {
        addElement(item);
        return item;
    }

    public synchronized E pop() {
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    public synchronized E peek() {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    public boolean empty() {
        return size() == 0;
    }

    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }
}

Stack<Integer> stack = new Stack<>();
stack.push(10); // Добавляет элемент 10 на вершину стека

int element = stack.pop(); // Удаляет и возвращает элемент 10

int topElement = stack.peek(); // Возвращает элемент 10, но не удаляет его

boolean isEmpty = stack.isEmpty(); // Возвращает false, так как стек не пуст

int position = stack.search(10); // Возвращает 1, так как элемент 10 на вершине стека

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        priorityQueue.add(4);
        priorityQueue.add(1);
        priorityQueue.add(3);

        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}

public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    private Object[] queue;
    private int size;
    private final Comparator<? super E> comparator;

    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

    public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
    }

    public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }

    // Основные методы: add, poll, offer, remove, etc.
}

import java.util.PriorityQueue;

public class PriorityQueueChallenge {
    public static void main(String[] args) {
        PriorityQueue<String> pq = new PriorityQueue<>();
        pq.add("apple");
        pq.add("banana");
        pq.add("cherry");
        pq.add("date");
        pq.add("elderberry");

        StringBuilder result = new StringBuilder();

        while (!pq.isEmpty()) {
            String value = pq.poll();
            if (value.length() % 2 == 0) {
                pq.add(value.substring(1));
            } else {
                result.append(value.charAt(0));
            }
        }

        System.out.println("Result: " + result);
    }
}

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(10);
pq.add(20);
pq.add(15);

pq.offer(5);

Integer top = pq.poll(); // Возвращает 5 и удаляет его из очереди

Integer top = pq.peek(); // Возвращает 10, но не удаляет его

boolean removed = pq.remove(15); // Удаляет элемент 15

boolean contains = pq.contains(20); // Проверяет наличие элемента 20

int size = pq.size(); // Возвращает количество элементов в очереди

import java.util.PriorityQueue;
import java.util.Comparator;

class Task {
    private String name;
    private int priority;

    public Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return name + ": " + priority;
    }
}

class TaskComparator implements Comparator<Task> {
    public int compare(Task t1, Task t2) {
        return Integer.compare(t1.getPriority(), t2.getPriority());
    }
}

public class TaskScheduler {
    public static void main(String[] args) {
        PriorityQueue<Task> taskQueue = new PriorityQueue<>(new TaskComparator());

        taskQueue.add(new Task("Task 1", 2));
        taskQueue.add(new Task("Task 2", 1));
        taskQueue.add(new Task("Task 3", 3));

        while (!taskQueue.isEmpty()) {
            System.out.println(taskQueue.poll());
        }
    }
}

PriorityQueue<Integer> reversePQ = new PriorityQueue<>(Comparator.reverseOrder());

reversePQ.add(10);
reversePQ.add(20);
reversePQ.add(15);

while (!reversePQ.isEmpty()) {
    System.out.println(reversePQ.poll());
}

import java.util.PriorityQueue;

class Job implements Comparable<Job> {
    private String jobName;
    private int executionTime;

    public Job(String jobName, int executionTime) {
        this.jobName = jobName;
        this.executionTime = executionTime;
    }

    @Override
    public int compareTo(Job other) {
        return Integer.compare(this.executionTime, other.executionTime);
    }

    @Override
    public String toString() {
        return jobName + ": " + executionTime;
    }
}

public class JobScheduler {
    public static void main(String[] args) {
        PriorityQueue<Job> jobQueue = new PriorityQueue<>();

        jobQueue.add(new Job("Job 1", 30));
        jobQueue.add(new Job("Job 2", 10));
        jobQueue.add(new Job("Job 3", 20));

        while (!jobQueue.isEmpty()) {
            System.out.println(jobQueue.poll());
        }
    }
}