10828번: 스택

첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지

www.acmicpc.net

 

Language: Java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        int cnt = Integer.parseInt(br.readLine());
 
        Stack<String> stack = new Stack<>();
 
        StringBuffer sb = new StringBuffer();
 
        while (cnt-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
 
            switch (st.nextToken()) {
            case "push":
                stack.push(st.nextToken());
                break;
            case "top":
                if (!stack.isEmpty()) {
                    sb.append(stack.lastElement() + "\n");
                } else {
                    sb.append("-1\n");
                }
                break;
            case "size":
                sb.append(stack.size() + "\n");
                break;
            case "empty":
                sb.append((stack.isEmpty() ? "1" : "0"+ "\n");
                break;
            case "pop":
                if (!stack.isEmpty()) {
                    sb.append(stack.lastElement() + "\n");
                    stack.pop();
                } else {
                    sb.append("-1\n");
                }
                break;
            }
 
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
 
    }
 
}
 
 
 

🤔 해설

1. case "push":

    - 입력값이 push일 경우, 입력값을 추가로 받음

 

😮 이 외의 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
 
public class Main {
 
    static int[] stack;
    static int location = 0;
 
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        StringBuilder sb = new StringBuilder();
 
        int N = Integer.valueOf(br.readLine());
 
        stack = new int[N];
 
        StringTokenizer st;
 
        while (N-- > 0) {
            st = new StringTokenizer(br.readLine(), " ");
 
            switch (st.nextToken()) {
            case "push":
                push(Integer.parseInt(st.nextToken()));
                break;
            case "pop":
                sb.append(pop()).append("\n");
                break;
            case "size":
                sb.append(size()).append("\n");
                break;
            case "empty":
                sb.append(empty()).append("\n");
                break;
            case "top":
                sb.append(top()).append("\n");
                break;
            }
 
        }
 
        bw.append(sb.toString());
 
        bw.flush();
        bw.close();
    }
 
    public static void push(int i) {
        stack[location] = i;
        location++;
    }
 
    public static int pop() {
        if (location == 0) {
            return -1;
        } else {
            int result = stack[location - 1];
            stack[location - 1= 0;
            location--;
            return result;
        }
    }
 
    public static int size() {
        return location;
    }
 
    public static int empty() {
        return location == 0 ? 1 : 0;
    }
 
    public static int top() {
        return location == 0 ? -1 : stack[location - 1];
    }
 
}
 
 
 

1. static int[] stack;

    - int[]로 stack 구현

 

2. static int location = 0;

    - 배열의 위치 반환

 

3. public static void push(int i) { ... }

    - 현재 위치에 입력값 삽입

    - location 위치 오른쪽으로 이동

 

4. public static int pop() { ... }

    - 가장 마지막에 위치한 요소 출력 및 0 대입

    - location 위치 왼쪽으로 이동

 

5. public static int size() { ... }

    - location 출력

 

 

 

🔗 소스 코드
GitHub

 

📚 참고 자료

 

[백준] 10828번 : 스택 - JAVA [자바]

www.acmicpc.net/problem/10828 10828번: 스택 첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보

st-lab.tistory.com

 

 

10820번: 문자열 분석

문자열 N개가 주어진다. 이때, 문자열에 포함되어 있는 소문자, 대문자, 숫자, 공백의 개수를 구하는 프로그램을 작성하시오. 각 문자열은 알파벳 소문자, 대문자, 숫자, 공백으로만 이루어져 있

www.acmicpc.net

 

Language: Java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class Main {
 
    static StringBuffer sb = new StringBuffer();
 
    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;
        while ((s = br.readLine()) != null) {
            check(s);
        }
 
        bw.append(sb + "");
 
        bw.flush();
        bw.close();
    }
 
    public static void check(String s) {
        int small_letter = 0;
        int capital_letter = 0;
        int number_letter = 0;
        int blank_letter = 0;
 
        int len = s.length();
 
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
 
            if (c > 96) {
                small_letter++;
            } else if (c > 64) {
                capital_letter++;
            } else if (c > 47) {
                number_letter++;
            }
        }
 
        blank_letter = len - (small_letter + capital_letter + number_letter);
 
        sb.append(small_letter + " " + capital_letter + " " + number_letter + " " + blank_letter + "\n");
 
    }
 
}
 
 

🤔 해설

1. while ((s = br.readLine()) != null) {...}

    - BufferedReader를 활용한 EOF 처리

 

2. check(String s)

    - if 조건문: 소문자부터 처리하여 범위를 한쪽만 설정할 수 있도록 조정

 

😮 이 외의 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class Main {
 
    static StringBuffer sb = new StringBuffer();
 
    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;
        while ((s = br.readLine()) != null) {
            check(s);
        }
 
        bw.append(sb + "");
 
        bw.flush();
        bw.close();
    }
 
    public static void check(String s) {
        int small_letter = 0;
        int capital_letter = 0;
        int number_letter = 0;
        int blank_letter = 0;
 
        int len = s.length();
 
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
 
            if (Character.isUpperCase(c))
                capital_letter++;
            if (Character.isLowerCase(c))
                small_letter++;
            if (Character.isDigit(c))
                number_letter++;
        }
 
        blank_letter = len - (small_letter + capital_letter + number_letter);
 
        sb.append(small_letter + " " + capital_letter + " " + number_letter + " " + blank_letter + "\n");
 
    }
 
}
 
 
 

1. if (Character.isUpperCase(c))

    - 대문자 확인

 

2. if (Character.isLowerCase(c))

    - 소문자 확인

 

3. if (Character.isDigit(c))

    - char 타입 숫자 확인

 

🎸 StringBuffer.append()

    - sb.append(small_letter + " " + capital_letter + " " + number_letter + " " + blank_letter + "\n");

    -  sb.append(small_letter).append(" ")

            .append(capital_letter).append(" ")

            .append(number_letter).append(" ")

            .append(blank_letter).append("\n");

한 번에 append하기보다는 나누어 append 하는 게 속도가 조금 더 빠름

 

 

 

🔗 소스 코드
GitHub

 

📚 참고 자료

 

[백준] 10820번 : 문자열 분석 – JAVA [자바]

https://www.acmicpc.net/problem/10820 10820번: 문자열 분석 문자열 N개가 주어진다. 이때, 문자열에 포함되어 있는 소문자, 대문자, 숫자, 공백의 개수를 구하는 프로그램을 작성하시오. 각 문자열은 알파

propercoding.tistory.com

 

 

9093번: 단어 뒤집기

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있으며, 문장이 하나 주어진다. 단어의 길이는 최대 20, 문장의 길이는 최대 1000이다. 단어와 단어 사이에는

www.acmicpc.net

 

Language: Java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;
import java.util.StringTokenizer;
 
public class Main {
 
    static StringBuffer sb = new StringBuffer();
 
    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 N = Integer.parseInt(br.readLine());
 
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
 
            while (st.hasMoreTokens()) {
                make_stack(st.nextToken());
            }
 
            sb.append("\n");
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
    public static void make_stack(String s) {
        Stack<Character> stack = new Stack<>();
        for (int j = 0; j < s.length(); j++) {
            stack.push(s.charAt(j));
        }
 
        for (int j = 0; j < s.length(); j++) {
            sb.append(stack.pop() + "");
        }
 
        sb.append(" ");
 
    }
 
}
 
 
 

🤔 해설

1. make_stack

    - " "을 기준으로 String을 나누어 Stack에서 후입선출로 sb에 저장

 

😮 이 외의 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
 
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 N = Integer.valueOf(br.readLine());
 
        StringBuilder reverse = new StringBuilder();
 
        while (N-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            while (st.hasMoreTokens()) {
                StringBuilder origin = new StringBuilder();
                origin.append(st.nextToken());
                reverse.append(origin.reverse()).append(" ");
            }
            reverse.append("\n");
        }
 
        bw.write(reverse.toString());
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

1. StringBuilder reverse = new StringBuilder();

    - reverse된 단어가 저장될 StringBuilder

 

2. reverse.append(origin.reverse()).append(" ");

    - origin StringBuilder를 reverse하여 reverse StringBuilder에 저장

 

 

 

🎸 Integer에서 parseInt와 valueOf 차이

- Integer.parseInt()

    - 기본 정수 데이터 타입(int)을 반환
    - 정수로 변환할 수 없는 문자열이나 형식이 들어오면 NumberFormatException 발생

- Integer.valueOf()

    - Integer 클래스의 객체를 반환

    - 정수로 변환할 수 없는 문자열이나 형식이 들어오면 NumberFormatException 발생

 

🎸 StringTokenizer에서 Element, Token

- 데이터의 작은 조각이나 단위

    - Element: 배열, 리스트, 집합 등의 데이터 구조에서 각각의 데이터 항목은 "element"

    - Token: 문자열을 구분자나 패턴을 기준으로 분리했을 때 얻어지는 작은 조각

 

🎸 reverse + "" 와 reverse.toString() 차이

- reverse + ""

    - 내부적으로 StringBuilder의 toString() 메서드를 호출하여 문자열로 변환 후, 빈 문자열("")과의 문자열 결합 연산을 통해 새로운 문자열을 생성

- reverse.toString()

    - StringBuilder 객체에 저장된 문자열을 새로운 문자열 객체로 복사

    - 원래의 StringBuilder 객체를 변경하지 않음

* 성능 상 큰 차이는 없지만, 코드 가독성과 유지보수 측면에서는 sb.toString()을 사용하는 것이 좋음

 

 

 

🔗 소스 코드
GitHub

 

📚 참고 자료

 

[백준] 9093번 단어 뒤집기 자바(Java)

https://www.acmicpc.net/problem/9093 9093번: 단어 뒤집기 첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있으며, 문장이 하나 주어진다. 단어의 길이는 최대 20, 문장

dev-coco.tistory.com

 

 

18870번: 좌표 압축

수직선 위에 N개의 좌표 X1, X2, ..., XN이 있다. 이 좌표에 좌표 압축을 적용하려고 한다. Xi를 좌표 압축한 결과 X'i의 값은 Xi > Xj를 만족하는 서로 다른 좌표 Xj의 개수와 같아야 한다. X1, X2, ..., XN에

www.acmicpc.net

 

Language: Java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
 
public class Main {
 
    static List<Long> list2;
 
    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 N = Integer.parseInt(br.readLine());
 
        Set<Long> set = new TreeSet<>();
 
        List<Long> list = new ArrayList<>();
 
        StringTokenizer st = new StringTokenizer(br.readLine());
 
        for (int i = 0; i < N; i++) {
            long num = Long.parseLong(st.nextToken());
            set.add(num);
            list.add(num);
        }
 
        list2 = new ArrayList<>();
 
        for (Long l : set) {
            list2.add(l);
        }
 
        StringBuffer sb = new StringBuffer();
 
        for (int i = 0; i < N; i++) {
            sb.append(list2.indexOf(list.get(i)) + " ");
        }
 
        bw.write(sb + "");
 
        bw.flush();
        bw.close();
    }
 
}
 
 
 

🤔 해설

1. Set<Long> set = new TreeSet<>();

    - TreeSet 이진검색트리* 방법으로 오름차순정렬

 

* 이진검색트리

    - 각 노드가 왼쪽 서브 트리의 모든 값보다 크고 오른쪽 서브 트리의 모든 값보다 작음

    - 평균적으로 O(log n)의 시간 복잡도

 

2. List<Long> list = new ArrayList<>();

    - 입력 순서대로 list에 저장

    ▶ 입력 순서대로 출력하기 위해 list2에서 인덱스 값 출력용으로 활용

 

3. list2 = new ArrayList<>();

    - static으로 선언했으나, 당시 메서드를 따로 만들어서 작업하려고 했던 부분으로 instance로 생성해도 됨

    - 정렬된 set값을 list2에 저장

    ▶ Treeset은 index를 통해 접근할 수 없어, 인덱스를 통해 접근하는 list 생성

 

4. list2.indexOf(list.get(i)) + " ")

    - set값이 저장된 list2는 오름차순 정렬되어있으므로, 입력 순서가 저장된 list 값을 대입해 list2의 index 값을 출력

 

 

😮 이 외의 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        int N = Integer.parseInt(br.readLine());
 
        int[] origin = new int[N];
        int[] sorted = new int[N];
 
        Map<Integer, Integer> map = new HashMap<>();
 
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        
        for (int i = 0; i < N; i++) {
            int element = Integer.parseInt(st.nextToken());
            sorted[i] = element;
            origin[i] = element;
        }
 
        Arrays.sort(sorted);
 
        int rank = 0;
        for (int v : sorted) {
            if (!map.containsKey(v)) {
                map.put(v, rank);
                rank++;
            }
        }
 
        StringBuilder sb = new StringBuilder();
        for (int key : origin) {
            int ranking = map.get(key);
            sb.append(ranking).append(" ");
        }
        
        bw.write(sb.toString());
 
        bw.flush();
        bw.close();
 
    }
 
}
 

1. int[] origin = new int[N];

    - 입력 순서가 저장된 int[]

 

2. int[] sorted = new int[N];

    - origin 배열을 정렬한 sorted[]

 

3. if (!map.containsKey(v)) {...}

    - 오름차순 정렬된 sort값을 0, 1, 2로 변환

    - !map.containsKey(v)

        - 같은 값일 경우, 순위가 동일해야하므로 기존에 key값이 없을 경우만 map에 저장

        - 같은 값을 가진 숫자가 2개 이상이더라도, 다음 값은 rank+1만큼만 증가

 

4. for (int key : origin) {...}

    - 기존 입력값의 순위(rank) 값 출력

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        int N = Integer.parseInt(br.readLine());
 
        int[] origin = new int[N];
 
        Map<Integer, Integer> map = new TreeMap<>();
 
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
 
        for (int i = 0; i < N; i++) {
            int element = Integer.parseInt(st.nextToken());
            origin[i] = element;
            map.put(element, 0);
        }
 
        int ranking = 0;
        for (int key : map.keySet()) {
            map.replace(key, ranking);
            ranking++;
        }
 
        StringBuilder sb = new StringBuilder();
        for (int key : origin) {
            sb.append(map.get(key)).append(" ");
        }
 
        bw.write(sb.toString());
 
        bw.flush();
        bw.close();
 
    }
 
}
 
 
 

1. Map<Integer, Integer> map = new TreeMap<>();

    - Map: 중복값 제거

    - TreeMap: 오름차순 정렬

 

2. for (int key : map.keySet()) {...}

    - key값의 value를 ranking 값으로 변환

 

 

 

🔗 소스 코드
GitHub

 

📚 참고 자료

 

[백준] 18870번 : 좌표 압축 - JAVA [자바]

https://www.acmicpc.net/problem/18870 18870번: 좌표 압축 수직선 위에 N개의 좌표 X1, X2, ..., XN이 있다. 이 좌표에 좌표 압축을 적용하려고 한다. Xi를 좌표 압축한 결과 X'i의 값은 Xi > Xj를 만족하는 서로 다

st-lab.tistory.com

 

 

1037번: 약수

첫째 줄에 N의 진짜 약수의 개수가 주어진다. 이 개수는 50보다 작거나 같은 자연수이다. 둘째 줄에는 N의 진짜 약수가 주어진다. 1,000,000보다 작거나 같고, 2보다 크거나 같은 자연수이고, 중복되

www.acmicpc.net

 

Language: Java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
 
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 min = 1_000_000;
        int max = 1;
        
        int N = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++) {
            int M = Integer.parseInt(st.nextToken());
            
            min = min <= M ? min : M;
            max = max >= M ? max : M;
            
        }
 
        bw.write(min * max + "");
        
        bw.flush();
        bw.close();
    }
 
}
 
 
 

🤔 해설

1. bw.write(min * max + "");

    - 1과 자기 자신을 제외한 가장 작은수와 가장 작은 수를 곱하면 N

 

 

 

🔗 소스 코드
HJ0216/TIL/BOJ