[JAVA] 백준 17413번 : 단어 뒤집기 2

 

---

 

• 생각

1. 코테보면 나올만한 문제인 것 같다. 다음과 같은 조건을 주의해서 코드를 짜면 될 것 같다.

 

조건 ) 1. <문자열>은 뒤집지 않고 출력 2. 문자열'띄어쓰기' or 문자열'문자열끝' 문자열 부분을 뒤집어서 출력

 

2. 스택을 잘 사용하면 시간이 더 빠르게 나올 것 같다.

 

3. StringTokenizer - 띄어쓰기된 문자열별로 .nextToken()으로 받아와서 작업해도 더 빠를 것 같다.

 

• 코드

정답 코드 : 위의 조건들을 고려하여서 코드를 짰다.

 

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class Main {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = br.readLine();
		String temp = "";
		StringBuilder sb = new StringBuilder();

		boolean check = false;
		for(int i = 0; i < s.length(); i++) {
			if(s.charAt(i) == '<')		// 뒤집지 않는 시작 문자 
				check = true;
			
			if(check)			// 뒤집지 않아야할 문자열
				temp = temp + s.charAt(i);
			else {				// 뒤집어야할 문자열
				if(s.charAt(i) == ' ')
					temp = temp + s.charAt(i);
				else
					temp = s.charAt(i) + temp;
			}
			
			if(s.charAt(i) == '>')		// 뒤집지 않는 끝 문자
				check = false;
			
			// ' ' or '>' or 문자열 끝이면 append
			if(s.charAt(i) == '>' || s.charAt(i) == ' ' || i == s.length()-1) {
				sb.append(temp);
				temp = "";
			}
			
		}
		System.out.println(sb);
	}
}

 

 

다른 사람 코드 : 스택으로 구현한 코드.

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;

public class Main {
    public static final char START_TAG = '<';
    public static final char END_TAG = '>';
    public static final char SPACE = ' ';

    public static void main(String args[]) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));) {
            String line = br.readLine();
            StringBuffer result = new StringBuffer();
            Stack<Character> word = new Stack<>();
            Boolean isTag = Boolean.FALSE;
            for (char c : line.toCharArray()) {
                if (c == START_TAG) {
                    if (!word.isEmpty()) {
                        result.append(reverse(word));
                    }
                    isTag = Boolean.TRUE;
                    result.append(c);
                } else if (c == END_TAG) {
                    result.append(c);
                    isTag = Boolean.FALSE;
                } else if (c == SPACE) {
                    if (isTag) {
                        result.append(c);
                    } else {
                        result.append(reverse(word));
                        result.append(SPACE);
                    }
                } else {
                    if (isTag) {
                        result.append(c);
                    } else {
                        word.add(c);
                    }
                }
            }
            if (!word.isEmpty()) {
                result.append(reverse(word));
            }
            bw.write(result.toString() + System.lineSeparator());

        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

    static String reverse(Stack<Character> input) {
        StringBuffer sb = new StringBuffer();
        while (!input.empty()) {
            sb.append(input.pop());
        }
        return sb.toString();
    }
}

 

다른 사람 코드 : StringTokenizer를 통해 구현한 코드가 있었다. 내가 생각했던 방식보다 더 활용을 잘한 코드이다. 제일 빨랐던 코드인만큼 공부하면 좋을 것 같다.

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

	static void solve(String target) {
		StringBuilder builder = new StringBuilder();
		StringTokenizer leftTagTokenizer = new StringTokenizer(target, "<");
		while (leftTagTokenizer.hasMoreTokens()) {
			String leftToken = leftTagTokenizer.nextToken();
			boolean includeTag = leftToken.contains(">");
			StringTokenizer rightTagTokenizer = new StringTokenizer(leftToken, ">");
			while (rightTagTokenizer.hasMoreTokens()) {
				if (includeTag) {
					builder.append("<");
					builder.append(rightTagTokenizer.nextToken());
					builder.append(">");
					includeTag = false;
				} else {
					String tagToken = rightTagTokenizer.nextToken();
					StringTokenizer spaceTokenizer = new StringTokenizer(tagToken);
					while (spaceTokenizer.hasMoreTokens()) {
						StringBuilder reverseBuilder = new StringBuilder(spaceTokenizer.nextToken());
						reverseBuilder.reverse();
						builder.append(reverseBuilder);
						if (spaceTokenizer.hasMoreTokens()) {
							builder.append(" ");
						}
					}
				}
			}
		}
		System.out.println(builder);
	}

	public static void main(String[] args) throws IOException {
		String line = reader.readLine();
		solve(line);
	}
}