// 애라토스테네스의 체
    public static void main(String[] args) {
        int maxNum = 100;
        boolean[] isComposite = new boolean[maxNum + 1];
    
        for (int i = 2; i*i < maxNum; i++) {
            if (!isComposite[i]) {
                for (int j = i; i*j <= maxNum; j++) {
                    isComposite[i*j] = true;
                }
            }
        }
    
        for (int i = 2; i <= maxNum ; i++ ) {
            if (!isComposite[i]) {
                System.out.println (i);
            }
        }
    }

    // 제곱근 
    static boolean isPrime(int num) {
        if(num <= 1) return false;
        if(num == 2) return true;
        if(num % 2 == 0) return false;

        int sqrt = (int)Math.sqrt(num);
        for(int i = 3; i <= sqrt; i+=2) {
            if(num % i == 0) {
                return false;
            }
        }
        return true;
    }

   int quotient = number / divisor;  // 몫 구하기
   int remainder = number % divisor; // 나머지 구하기

String binary = Integer.toBinaryString(num);    // 2 진수
String octal = Integer.toOctalString(num);      // 8 진수
String hexadecimal = Integer.toHexString(num);  // 16 진수

public static void primeFactors(int number) {
        // Print the number of 2s that divide number
        while (number % 2 == 0) {
            System.out.print(2 + " ");
            number /= 2;
        }

        // n must be odd at this point, thus skip the even numbers and iterate only for odd
        for (int i = 3; i <= Math.sqrt(number); i += 2) {
            // While i divides n, print i and divide n
            while (number % i == 0) {
                System.out.print(i + " ");
                number /= i;
            }
        }

        // This condition is to handle the case when number is a prime number greater than 2
        if (number > 2)
            System.out.print(number);
    }

    import java.util.LinkedList;
    import java.util.Queue;
    
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
        q.offer(1);
        q.offer(2);
        q.offer(3);
        
        // 예상 출력 값 1
        q.poll();
        
        // false
        q.isEmpty();
        
        // 2
        q.size();
        
        // false
        q.contains(4);
    }

    import java.util.*;

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        
        // 3
        stack.pop();
        
        // false
        stack.isEmpty();
        
        // 2
        stack.size();
        
        // true
        stack.contains(2);
        
        // 1
        stack.get(0);
    }

    public class Node {
        int data;
        Node next;
    
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
    
    public class LinkedList {
        Node head;
    
        public void add(int data) {
            Node newNode = new Node(data);
            if (head == null) {
                head = newNode;
            } else {
                Node last = head;
                while (last.next != null) {
                    last = last.next;
                }
                last.next = newNode;
            }
        }
    
        public void print() {
            Node current = head;
            while (current != null) {
                System.out.print(current.data + " ");
                current = current.next;
            }
            System.out.println();
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            LinkedList list = new LinkedList();
            list.add(1);
            list.add(2);
            list.add(3);
            list.print();  // 출력: 1 2 3
        }
    }

import java.util.Deque;
import java.util.LinkedList;

Deque<Integer> deque = new LinkedList<>();
// 마지막에 추가
deque.addLast(1);
deque.offerLast(2); // 위와 같은 작업
// 처음에 추가
deque.addFirst(0);
deque.offerFirst(-1); // 위와 같은 작업
// 마지막 요소를 제거하고 반환
int lastElement = deque.removeLast();
int lastElement = deque.pollLast(); // 위와 같은 작업, 하지만 데크가 비어 있을 경우 null 반환
// 시작 부분의 요소를 제거하고 반환:
int firstElement = deque.removeFirst();
int firstElement = deque.pollFirst(); // 위와 같은 작업, 하지만 데크가 비어 있을 경우 null 반환
// 마지막 요소를 반환하되 제거하지 않음:
int lastElement = deque.getLast();
int lastElement = deque.peekLast(); // 위와 같은 작업, 하지만 데크가 비어 있을 경우 null 반환
// 시작 부분의 요소를 반환하되 제거하지 않음:
int firstElement = deque.getFirst();
int firstElement = deque.peekFirst(); // 위와 같은 작업, 하지만 데크가 비어 있을 경우 null 반환
// deque 빈요소 반환
deque.clear();

public int solution(String a, String b) {
        int answer = 0;
        HashMap<Character, Integer> am = new HashMap<>();
        HashMap<Character, Integer> bm = new HashMap<>();

        // 사전 세팅
        for (char x : b.toCharArray()) {
            bm.put(x, bm.getOrDefault(x, 0) + 1);
        }
        int L = b.length() - 1;
        for (int i = 0; i < L; i++) {
            am.put(a.charAt(i), am.getOrDefault(a.charAt(i), 0) + 1);
        }

        // 투포인트 알고리즘, 슬라이딩 윈도우, 아나그램 알고리즘 equals
        int lt = 0;
        for (int rt = L; rt < a.length(); rt++) {
            am.put(a.charAt(rt), am.getOrDefault(a.charAt(rt), 0) + 1);
            if (am.equals(bm)) {
                answer++;
            }
            am.put(a.charAt(lt), am.get(a.charAt(lt)) - 1);
            if (am.get(a.charAt(lt)) == 0) {
                am.remove(a.charAt(lt));
            }
            lt++;
        }


        return answer;
    }