[BaekJoon] 10951๋ฒ - A+B - 4 (java)
1. ๋ฌธ์
๐ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
- ์กฐ๊ฑด
์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ |
---|---|
1์ด | 256MB |
- ๋ฌธ์
๋ ์ ์ A์ B๋ฅผ ์
๋ ฅ๋ฐ์ ๋ค์, A+B๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ ๋ ฅ
์
๋ ฅ์ ์ฌ๋ฌ ๊ฐ์ ํ
์คํธ ์ผ์ด์ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค๋ ํ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (0 < A, B < 10)
- ์ถ๋ ฅ
๊ฐ ํ
์คํธ ์ผ์ด์ค๋ง๋ค A+B๋ฅผ ์ถ๋ ฅํ๋ค.
- ์์
ย ย ์ ๋ ฅย ย | ย ย ์ถ๋ ฅย ย |
---|---|
1 1 2 3 3 4 9 8 5 2 |
2 5 7 17 7 |
2. ํ์ด
๋ฐ๋ณต๋ฌธ while
๋ฅผ ์ฌ์ฉํด ์ฒซ ์ค์ ์
๋ ฅ๋ฐ์ ๊ฐ๋งํผ A + B๋ฅผ ๋ฐ๋ณตํ๋ค.
์กฐ๊ฑด์์ ๊ฒฐ๊ณผ๊ฐ ์ฐธ์ธ ๋์ ๋ฐ๋ณต์ ์ผ๋ก ์คํํ๊ณ ์ ํ๋ ๋ช ๋ น๋ฌธ ์์ฑ;
}
์ด ๋ฌธ์ ์ ํฌ์ธํธ๋
์ข ๋ฃ ์กฐ๊ฑด ์์ด
๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๋ ๊ฒ์ด๋ค.
์ฆ ๋์ด์ ์ฝ์ด์ฌ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ์ง ์์ ๋(* EOF), ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๋ค.
End Of File ์ ์ฝ์๋ก, ๋ฐ์ดํฐ ์์ค๋ก๋ถํฐ ๋์ด์ ์ฝ์ด์ฌ ์ ์๋ ๋ฐ์ดํฐ๊ฐ ์์์ ๋ํ๋ด๋ ์ฉ์ด์ด๋ค.
์๊ณ ๋ฆฌ์ฆ์์ ์ ๋ ฅ๊ฐ์ ์ข ๋ฃ ์กฐ๊ฑด์ด ์์ ๊ฒฝ์ฐ, EOF ๋ฅผ ์ฌ์ฉํด ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๋ค.
2๊ฐ์ ์
๋ ฅ๋ฐฉ์๊ณผ 2๊ฐ์ ์ถ๋ ฅ๋ฐฉ์์ ์ฌ์ฉํด์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
- Scanner ํด๋์ค (์ ๋ ฅ)
- BufferedReader ํด๋์ค (์
๋ ฅ)
ย ย โ StringBuilder (์ถ๋ ฅ)
ย ย โก BufferedWriter (์ถ๋ ฅ)
- 1. Scanner ํด๋์ค
Scanner ์ ๊ฒฝ์ฐ ๋์ด์ ์ฝ์ ๋ฐ์ดํฐ๊ฐ ์์ผ๋ฉด NoSuchElementException ์ ๋์ง๊ฒ ๋๋ค.
๊ทธ๋ฌ๋ IDE๋ ํฐ๋ฏธ๋์์ System.in(ํค๋ณด๋)
์ผ๋ก ์
๋ ฅ๋ฐ์ ๊ฒฝ์ฐ, Scanner ๋ Enter, Space๋ฅผ ์
๋ ฅํด๋ ์์ธ๋ฅผ ๋ฐ์์ํค์ง ์๋๋ค.
๋ฐ๋ผ์ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃ์ํค๋ ค๋ฉด Enter, Space๋ฅผ ์
๋ ฅ๋ฐ์ ๊ฒฝ์ฐ ์กฐ๊ฑด๋ฌธ์ ๊ฑธ์ด ์์ธ๋ฅผ ๋ฐ์์์ผ์ผํ๋ค.
๋๋, ctrl + Z(์๋์ฐ) / ctrl + D(๋ฆฌ๋
์ค๊ณ์ด) ์ ์
๋ ฅํด์ฃผ๊ฑฐ๋ ์ ์๊ฐ ์๋ ๋ฌธ์์ด์ ์
๋ ฅํ๋ ๋ฑ ๋ค๋ฅธ ํ์
์ ์
๋ ฅ์ ์ฃผ์ด InputMismatchException
์ ๋ฐ์์์ผ์ผ ํ๋ค.
๋ฐฑ์ค์์๋ ๋์ด์ ์ฝ์ ๋ฐ์ดํฐ๊ฐ ์๋๊ฒฝ์ฐ ๋น์ฐํ nextInt() ์์ ๋ฐ๋ ์
๋ ฅ์ด ์กด์ฌํ์ง ์์ ์์ธ๋ฅผ ๋์ ธ์ค๋ค. ๊ทธ๋์ ๋ฐ๋ก Enter, Space์ ๋ํด ์กฐ๊ฑด์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ง ์์๋ ๊ด์ฐฎ๋ค.
์์ธ ์ฒ๋ฆฌ์๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค.
- try ~ catch ๋ฌธ์ผ๋ก ์์ธ์ฒ๋ฆฌ
- Scanner์ ๋ฉ์๋์ธ hasNext() ๋๋ hasNextInt() ๋ฅผ ํตํด ์์ธ์ฒ๋ฆฌ
์ด ๋ฌธ์ ์์ hasNextInt() ๋ฅผ ์ฌ์ฉํด ์์ธ์ฒ๋ฆฌ๋ฅผ ํด๋ณด์.
import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
while(sc.hasNextInt()){
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(a+b);
}
sc.close();
}
}
์์๊ฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋, Scanner(System.in) ์์
System.in
์ ์ ๋ ฅํ ๊ฐ์Byte ๋จ์
๋ก ์ฝ๋ ๊ฒ์ ๋ปํ๋ค.
๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ ๋๋ง๋ค while ๋ฌธ์์
hasNextInt()
๋ก ์ ๋ ฅ๊ฐ์ ํ์ธํ ํ, nextInt()๋ก ์ ์ ๊ฐ์ ์ฝ์ด๋ค์ธ๋ค.
hasNextInt()
๋ ์ ๋ ฅ๊ฐ์ด ์ ์์ผ ๊ฒฝ์ฐ true๋ฅผ ๋ฐํํ๋ฉฐ, ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ false๋ฅผ ๋ฐํํ๋ฉด์ ๋ฐ๋ณต๋ฌธ์ด ์ข ๋ฃ๋๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
- 2. BufferedReader ํด๋์ค ์ฌ์ฉ
BufferedReader ์ ๊ฒฝ์ฐ null ์ ๋ฐํํ๋ค.
IDE๋ ํฐ๋ฏธ๋์์ BufferedReader๋ก null์ ๋ฐํํ๊ธฐ ์ํด์๋ ctrl + Z (์๋์ฐ) ๋๋ ctrl + D(๋ฆฌ๋
์ค)๋ฅผ ์
๋ ฅํด์ผํ๋ค.
BufferedReader ์ readLine()
์ ํ ์ค์ ํต์งธ๋ก ์ฝ์ด String์ผ๋ก ๋ฐํํ๊ธฐ ๋๋ฌธ์ " "(๊ณต๋ฐฑ)์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๊ตฌ๋ถํด์ผํ๋ค.
๋ฌธ์์ด ๋ถ๋ฆฌ ๋ฐฉ๋ฒ์๋ 2๊ฐ์ง๊ฐ ์๋ค.
- StringTokenizer ํด๋์ค
- String ํด๋์ค์ split() ๋ฉ์๋
์ด ๋ฌธ์ ์์๋ StringTokenizer ๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๋ค.
split() ๋ฉ์๋๋ ์ ๊ท์์ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด์ ๋ถ๋ฆฌํ๊ธฐ ๋๋ฌธ์, ์ฑ๋ฅ๋ฉด์์ ๋น๊ต์ ๋๋ฆฌ๋ค.
๊ทธ๋ฌ๋ StringTokenizer ํด๋์ค๋ ๊ตฌ๋ถ์๋ฅผ ๋จ์ผ ๋ฌธ์๋ก ์ฒ๋ฆฌํด ๋ณต์กํ ์ ๊ท์์ ์ฌ์ฉํ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๋ค.
2๊ฐ์ง ์ถ๋ ฅ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ณ ๋น๊ตํด๋ณด์.
ย ย ย ย โ StringBuilder
ย ย ย ย โก BufferedWriter
โ BufferedReader + StringBuilder
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main {
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
StringTokenizer st;
String str;
while((str = br.readLine()) != null){
st = new StringTokenizer(str," ");
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
sb.append(a+b).append("\n");
}
System.out.print(sb);
}
}
readLine() ์ ํตํด
str ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๊ฐ null ์ผ ๊ฒฝ์ฐ while ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃ
์ํค๊ณ , ์๋๊ฒฝ์ฐ ๋ฐ๋ณต๋ฌธ์ ๊ณ์ ์ํํ๋ค.
readLine()
์ ํ ์ค์ ํต์งธ๋ก ์ฝ์ด String์ผ๋ก ๋ฐํํ๊ธฐ ๋๋ฌธ์StringTokenizer ํด๋์ค
๋ฅผ ์ฌ์ฉํด โ โ(๊ณต๋ฐฑ)์ ๊ธฐ์ค์ผ๋ก ๊ฐ์ ๊ตฌ๋ถํ๊ณ ,nextToken()
๋ฅผ ์ฌ์ฉํด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ์ ๋ ฅ๊ฐ๋ค์ ์์๋๋ก ๊ฐ์ ธ์จ๋ค.
Integer.parseInt()
์ ์ฌ์ฉํด Stringํ์intํ์ผ๋ก ๋ณํ
์์ผ์ค๋ค.
StringBuilder ํด๋์ค
๋ ๋ฌธ์์ด์ ๋์ ์ผ๋ก ์กฐ์ํ๊ธฐ ์ํ ํด๋์ค๋ก,append()
๋ฅผ ์ฌ์ฉํด ๋ฌธ์์ด์ ์ถ๊ฐํ์ฌ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ๋ค.
append()
๋ฅผ ์์ ๊ฐ์ด ๋๋ ์ ์ฐ๋ฉด ํ์ ๋ณํ๊ณผ ๋ฌธ์์ด ์ฐ๊ฒฐ ์ฐ์ฐ์ด ์ถ๊ฐ์ ์ผ๋ก ๋ฐ์ํ์ง ์๊ณ StringBuilder์ ์ง์ ์ถ๊ฐํ๊ธฐ ๋๋ฌธ์ ๋ณด๋ค ๋ ํจ์จ์ ์ด๊ณ ๋น ๋ฅด๋ค.
โก BufferedReader + BufferedWriter
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedWriter;
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));
StringTokenizer st;
String str;
while ((str = br.readLine()) != null) {
st = new StringTokenizer(str, " ");
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
bw.write(a + b + "\n");
}
br.close();
bw.flush();
bw.close();
}
}
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ถ ๋ฒํผ์ ์ ์ฅํ๊ณ ,flush() ๋ฉ์๋
๋ฅผ ์ฌ์ฉํด ๋ฒํผ๋ฅผ ๋น์ฐ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ค.
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋จ๋ ์ผ๋ก int ํ ๊ฐ๋ง ๋ฃ์ ๊ฒฝ์ฐ ์์คํค ์ฝ๋๊ฐ์ผ๋ก ์ธ์๋๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๋ฌธ์๊ฐ ์ถ๋ ฅ๋๋ค. ๋๋ฌธ์๋ฐ๋์ ๋ฌธ์์ด๊ณผ int ํ์ ํจ๊ป ๋ฃ์ด์ค์ผ
int ๊ฐ์ ์ ๋๋ก ์ถ๋ ฅํ ์ ์๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
BufferedWriter ํด๋์ค
์ ๋ํด ๋ ์์๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ฅผ ํด๋ฆญํ๋ฉด ๋๋ค.3. ์ฑ๋ฅ ๋น๊ต
์์์ ๋ถํฐ ์์๋๋ก
BufferedReader + StringBuilder
BufferedReader + BufferedWriter
Scanner
์์๊ฐ์ด ์
๋ ฅ ๋ฉ์๋์ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค.
์
๋ ฅ์ ๊ฒฝ์ฐ ํ์คํ Scanner ๋ณด๋ค๋ BufferedReader ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ถ๋ ฅ์ ๊ฒฝ์ฐ BufferedWriter ๋ณด๋ค๋ StringBuilder ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
(๊ทธ๋ฌ๋ ๋ฐ์ดํฐ ์์ด ์ปค์ง๋ฉด ์ปค์ง ์๋ก BufferedWriter ๊ฐ ๋ ๋น ๋ฅด๋ค.)
BufferedWriter๋ ์ผ๋ฐ์ ์ผ๋ก I/O ์์
์ผ๋ก ์ธํด ๋น๊ต์ ๋๋ฆด ์ ์๋ค.
๋ฐ๋ฉด์ StringBuilder๋ ๋ฌธ์์ด ์กฐ์์ ์ต์ ํ๋ ํด๋์ค๋ก, ๋ฌธ์์ด ์ฐ์ฐ์ ์ผ๋ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์์์ ์ํ๋๋ฏ๋ก ์๋์ ์ผ๋ก ๋น ๋ฅผ ์ ์๋ค.
๊ด๋ จ ํ์ด์ง
Leave a comment