잡다한 배똥월드

import java.io.*;
import java.util.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//괄호 줄 입력 받아서 char 배열로 변환
		//String 배열을 쓰지 않은 이유는 '('냐 ')'냐 비교할 때 
		char[] pipe = br.readLine().toCharArray();
		//괄호 문제여서 그냥 스택을 썼지만 그냥 int 써도 괜찮음
		Stack<Character> s = new Stack<>();
		//result는 쇠파이프 조각 개수
		int result = 0;
		for (int i = 0; i < pipe.length-1; i++) {
			만약 pipe[i]가 열린 괄호이고,
			if (pipe[i] == '(') {
				//만약 pipe[i+1]이 닫힌 괄호면
				if (pipe[i+1] == ')') {
					자르는 타이밍이기 때문에 스택의 개수 더해주고 i+1은 체크할 필요 없어서 i++
					result += s.size();
					i++;
				} else { //닫힌 괄호가 아니면 파이프의 시작 부분이기 때문에 스택에 추가
					s.add('(');
				}
			} else { //닫힌 괄호면 스택에서 하나 빼주고 개수 하나 더해줘야 함
				s.pop();
				result++;
			}
		}
		//마지막 문자열은 체크하지 않기 때문에 1 더해줘야함
		System.out.println(result+1);
	}
}

import java.io.*;
import java.util.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//입력 받을 숫자 개수
		int n = Integer.parseInt(br.readLine());
		//출력할 숫자 합계
		int result = 0;
	
		//스택으로 가장 최근 입력 받은 숫자 파악하기 
		Stack<Integer> s = new Stack<>();
		
		for (int i = 0; i < n; i++) {
			int num = Integer.parseInt(br.readLine());
			//만약 num이 0이면 스택 최상위 숫자 제거
			if (num == 0) {
				s.pop();
			} else { //0이 아니면 스택에 추가
				s.add(num);
			}
		}
		//스택의 숫자를 하나씩 꺼내면서 result에 더해주기
		while (!s.isEmpty()) {
			result += s.pop();
		}
		
		System.out.println(result);
	}
}

import java.io.*;
import java.util.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		String s = "";

		//br로 한 줄씩 입력 받는 것을 s에 넣고, 문장이 담긴 s가 .이 아닐 때까지 반복
		while (!(s = br.readLine()).equals(".")) {
			//s를 char 배열로 변환 => String 배열로 변환해도 되지만 시간을 단축시키려면 char을 활용하는 편이 좋음
			char[] arr = s.toCharArray();
			//여는 괄호를 담을 스택. 닫는 괄호가 나올 때 제일 위에 있는 괄호를 꺼내는 용도
			Stack<Character> stack = new Stack<>();
			//균형이 맞는지 파악용
			boolean check = true;
			
			for (int i = 0; i < arr.length; i++) {
				//만약 여는 괄호면 그냥 stack에 담기
				if (arr[i] == '(' || arr[i] == '[') stack.add(arr[i]);
				
				//만약 닫는 괄호라면
				if (arr[i] == ')' || arr[i] == ']') {
					//스택이 비어있지 않고, 닫는 소괄호면 스택 최상위가 여는 소괄호이거나 닫는 대괄호면 스택 최상위가 여는 대괄호라면
					if (!stack.isEmpty() && ((arr[i] == ')' && stack.peek() =='(') || (arr[i] == ']' && stack.peek() =='['))) {
						//스택 최상위 값 제거
						stack.pop();
					} else {
						//그렇지 않으면 균형이 맞지 않으므로 check에는 false를 담고 for문 끝내기
						check = false;
						break;
					}
				}
			}
			//마지막 확인으로 스택이 비어있지 않으면 균형이 맞지 않기 때문에 확인
			if (!stack.isEmpty()) check = false;
			//check가 true면 yes를, false면 no를 출력
			bw.write((check ? "yes" : "no") + "\n");
		}
		
		bw.flush();
		bw.close();
	}
}

import java.io.*;
import java.util.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	
		//임의의 자연수를 받기 위한 변수		
		int num;

		//시간복잡도를 잡기 위해서 이미 확인한 숫자들은 소수인지 아닌지 boolean으로 구분하며 해시맵에 담아둠
		HashMap<Integer, Boolean> map = new HashMap<>();
		
		//숫자를 받아오면서 바로 num에 담고, 담은 숫자가 0일 때까지 반복
		while ((num = Integer.parseInt(br.readLine())) != 0) {

			//출력용 숫자를 모을 변수
			int result = 0;
			
			//임의의 자연수 n보다 크고, 2n보다 작거나 같아야 하기 때문에 범위는 n+1 ~ 2n까지임
			for (int i = num + 1; i <= 2 * num; i++) {
				//만약 map에 숫자가 없으면
				if (map.getOrDefault(i, null) == null) {
				  //소수인지 파악하기
					boolean check = true;
					for (int j = 2; j <= Math.sqrt(i); j++) {
						if (i % j == 0) {
							check = false;
							break;
						}
					}
					//check가 true이면 소수, false이면 소수가 아닌 숫자
				  //그대로 map에 넣고, result 값도 추가
					map.put(i, check);
					result += check ? 1 : 0;
				} else { //만약 map에 있으면 map의 boolean에 따라 result 값 추가
					result += map.get(i) ? 1 : 0;
				}
			}		
			bw.write(result + "\n");
		}
		
		bw.flush();
		bw.close();
	}
}

import java.io.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
        //체크용 boolean 배열
		boolean[] list = new boolean[10001];
		
        //1부터 10000까지 d() 함수로 보내고 체크하기
		for (int i = 1; i <= 10000; i++) {
			int num = d(i); //d함수 리턴값 : 정수
            
            //만약 리턴값이 10000보다 작고, 만들어진 적 없는 숫자라면 true로 체크하기
			if (num <= 10000 && !list[num]) list[num] = true;
		}
		
        //1부터 10000까지 방문 기록이 없는 숫자는 출력하기
		for (int i = 1; i < list.length; i++) {
			if (!list[i]) bw.write(i + "\n");
		}
		
		bw.flush();
		bw.close();
	}
	
	public static int d(int num) {
		int result = num;
		while (num > 0) {
			result += (num % 10);
			num /= 10;
		}
		return result;
	}
}

import java.io.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
        //주어진 숫자
		int n = Integer.parseInt(br.readLine());
		
        //왼쪽 숫자
		int first = n / 10;
		//오른쪽 숫자
        int second = n % 10;
		
        //리턴할 횟수
		int result = 0;
        
        //while문은 계속 반복하다가 조건에 맞으면 탈출할 수 있도록 true 넣기
		while (true) {
			//while문이 시작하자마자 바로 횟수 + 1
            result++;
			
            //왼쪽 숫자와 오른쪽 숫자를 더해서 새로운 숫자를 만들고
			int create = first + second;
			
            //왼쪽 숫자에는 오른쪽 숫자를 재할당
            first = second;
            //오른쪽 숫자에는 새로 만든 숫자의 1의 자리 숫자를 할당
			second = create % 10;
			
            //만약 왼쪽 숫자와 오른쪽 숫자가 처음 주어진 숫자와 동일하다면 break
			if (first == n / 10 && second == n % 10) break;
		}		
		System.out.println(result);
	}
}

import java.io.*;
public class Main {
	public static void main(String[] args) throws IOException{
    	//입출력 객체들 선언
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        
       	//가장 첫 번째 줄은 배열의 길이와 질문의 개수가 나옴
        //띄어쓰기로 구분되어 있기 때문에
        //읽어 들이면서 split()으로 구분
		String[] nm = br.readLine().split(" ");
		
        //첫 번째 줄 숫자로 변환
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		
        //배열 a 선언
		int[] a = new int[n];
        
        //입력 순서대로 정수로 변환하면서 배열 채우기
		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(br.readLine());
		}
		
        //퀵 정렬 호출
		quick(a, 0, a.length-1);
		
		for (int i = 0; i < m; i++) {
			bw.write(check(Integer.parseInt(br.readLine()), a, 0, a.length-1) + "\n");
		}
		
		bw.flush();
		bw.close();
	}
	
	public static int check(int num, int[] a, int start, int end) {
		while (start+1 < end) {
			int mid = (start + end) / 2;
			
			if (a[mid] >= num) {
				end = mid;
			} else {
				start = mid;
			}
		}
		
		return a[start] == num ? start : a[end] == num ? end : -1;
	}
	
    //퀵 정렬 함수
	public static void quick(int[] a, int start, int end) {
    	//cutting 함수 호출 - 리턴값 정수
		int cut = cutting(a, start, end);
        
        
		if (start < cut-1) quick(a, start, cut-1);
		if (cut < end) quick(a, cut, end);
	}
	
	public static int cutting(int[] a, int start, int end) {
    	//중간 위치와 중간 위치의 값인 피벗 선언하기
		int mid = (start + end) / 2;
		int pivot = a[mid];
		
        //start가 end보다 작거나 같을 때까지 반복
		while (start <= end) {
        	//start위치의 값이 피벗보다 큰 경우까지 탐색
			while (a[start] < pivot) start++;
            
            //end위치의 값이 피벗보다 작은 경우까지 탐색
			while (a[end] > pivot) end--;
			
            //만약 start가 end보다 작거나 같으면 두 위치의 숫자 바꾸기
            //그리고 그 다음 위치로 각각 이동
			if (start <= end) {
				change(a, start, end);
				start++;
				end--;
			}
		}
		
		return start;
	}
	
    //두 위치 간의 숫자 바꾸는 함수
    public static void change(int[] a, int n1, int n2) {
		int temp = a[n1];
		a[n1] = a[n2];
		a[n2] = temp;
	}
}

import java.io.*;
public class Main {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        //숫자 가져오기
		int n = Integer.parseInt(br.readLine());
		
        //1부터 n번째 줄까지 줄 기준 for문
		for (int i = 1; i <= n; i++) {
        	//줄에 맞춰서 * 작성하는 for문
			for (int j = 1; j <= n; j++) {
            	//오른쪽 정렬을 위해 만약 n-j가 i보다 작을 경우 *, 아니면 띄어쓰기 입력
                //System.out.print는 줄 바꿈 안함
				if (n-j < i) System.out.print("*"); else System.out.print(" ");
			}
            //System.out.println은 줄 바꿈
			System.out.println("");
		}
	}
}