[BaekJoon] 11022๋ฒ - A+B - 8 (java)
1. ๋ฌธ์
๐ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
- ์กฐ๊ฑด
์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ |
---|---|
1์ด | 256MB |
- ๋ฌธ์
๋ ์ ์ A์ B๋ฅผ ์
๋ ฅ๋ฐ์ ๋ค์, A+B๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ ๋ ฅ
์ฒซ์งธ ์ค์ ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค๋ ํ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (0 < A, B < 10)
- ์ถ๋ ฅ
๊ฐ ํ
์คํธ ์ผ์ด์ค๋ง๋ค "Case #x: A + B = C" ํ์์ผ๋ก ์ถ๋ ฅํ๋ค. x๋ ํ
์คํธ ์ผ์ด์ค ๋ฒํธ์ด๊ณ 1๋ถํฐ ์์ํ๋ฉฐ, C๋ A+B์ด๋ค.
- ์์
ย ย ์ ๋ ฅย ย | ย ย ์ถ๋ ฅย ย |
---|---|
5 1 1 2 3 3 4 9 8 5 2 |
Case #1: 1 + 1 = 2 Case #2: 2 + 3 = 5 Case #3: 3 + 4 = 7 Case #4: 9 + 8 = 17 Case #5: 5 + 2 = 7 |
2. ํ์ด
๋ฐ๋ณต๋ฌธ for
๋ฅผ ์ฌ์ฉํด ์ฒซ ์ค์ ์
๋ ฅ๋ฐ์ ๊ฐ๋งํผ A + B๋ฅผ ๋ฐ๋ณตํ๋ค.
์กฐ๊ฑด์์ ๊ฒฐ๊ณผ๊ฐ ์ฐธ์ธ ๋์ ๋ฐ๋ณต์ ์ผ๋ก ์คํํ๊ณ ์ ํ๋ ๋ช ๋ น๋ฌธ ์์ฑ;
}
2๊ฐ์ ์
๋ ฅ๋ฐฉ์๊ณผ 3๊ฐ์ ์ถ๋ ฅ๋ฐฉ์์ ์ฌ์ฉํด์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
- Scanner ํด๋์ค (์ ๋ ฅ)
- BufferedReader ํด๋์ค (์
๋ ฅ)
ย ย โ StringBuilder (์ถ๋ ฅ)
ย ย โก BufferedWriter (์ถ๋ ฅ)
ย ย โข System.out.println() (์ถ๋ ฅ)
- 1. Scanner ํด๋์ค
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for (int i = 1; i <= num; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println("Case #" + i + ": " + a + " + " + b + " = " + (a + b));
}
sc.close();
}
}
์์๊ฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋, Scanner(System.in) ์์
System.in
์ ์ ๋ ฅํ ๊ฐ์Byte ๋จ์
๋ก ์ฝ๋ ๊ฒ์ ๋ปํ๋ค.
intํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด
nextInt()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
- 2. BufferedReader ํด๋์ค ์ฌ์ฉ
3๊ฐ์ง ์ถ๋ ฅ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ณ ๋น๊ตํด๋ณด์.
ย ย ย ย โ StringBuilder
ย ย ย ย โก BufferedWriter
ย ย ย ย โข System.out.println()
โ 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));
int num = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
StringTokenizer st;
for (int i = 1; i <= num; i++) {
st = new StringTokenizer(br.readLine()," ");
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
sb.append("Case #").append(i).append(": ").append(a).append(" + ").append(b).append(" = ");
sb.append(a+b).append("\n");
}
br.close();
System.out.println(sb);
}
}
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));
int num = Integer.parseInt(br.readLine());
StringTokenizer st;
for (int i = 1; i <= num; i++) {
st = new StringTokenizer(br.readLine()," ");
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
bw.write("Case #" + i + ": " + a + " + " + b + " = ");
bw.write(a+b+"\n");
}
br.close();
bw.flush();
bw.close();
}
}
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ถ ๋ฒํผ์ ์ ์ฅํ๊ณ ,flush() ๋ฉ์๋
๋ฅผ ์ฌ์ฉํด ๋ฒํผ๋ฅผ ๋น์ฐ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ค.
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋จ๋ ์ผ๋ก int ํ ๊ฐ๋ง ๋ฃ์ ๊ฒฝ์ฐ ์์คํค ์ฝ๋๊ฐ์ผ๋ก ์ธ์๋๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๋ฌธ์๊ฐ ์ถ๋ ฅ๋๋ค. ๋๋ฌธ์ ๋ฐ๋์ ๋ฌธ์์ด๊ณผ int ํ์ ํจ๊ป ๋ฃ์ด์ค์ผ int ๊ฐ์ ์ ๋๋ก ์ถ๋ ฅํ ์ ์๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
BufferedWriter ํด๋์ค
์ ๋ํด ๋ ์์๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ฅผ ํด๋ฆญํ๋ฉด ๋๋ค.โข BufferedReader + System.out.println()
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.IOException;
public class Main {
public static void main(String args[]) throws IOException {
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
int num = Integer.parseInt(br.readLine());
StringTokenizer st;
for (int i = 1; i <= num; i++) {
st = new StringTokenizer(br.readLine()," ");
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
System.out.println("Case #" + i + ": " + a + " + " + b + " = " + (a+b));
}
br.close();
}
}
3. ์ฑ๋ฅ ๋น๊ต
์์์ ๋ถํฐ ์์๋๋ก
BufferedReader + StringBuilder
BufferedReader + BufferedWriter
BufferedReader + System.out.println()
Scanner
์์๊ฐ์ด ์
๋ ฅ ๋ฉ์๋์ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค.
์
๋ ฅ์ ๊ฒฝ์ฐ ํ์คํ Scanner ๋ณด๋ค๋ BufferedReader ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ถ๋ ฅ์ ๊ฒฝ์ฐ BufferedWriter ๋ณด๋ค๋ StringBuilder ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
(๊ทธ๋ฌ๋ ๋ฐ์ดํฐ ์์ด ์ปค์ง๋ฉด ์ปค์ง ์๋ก BufferedWriter ๊ฐ ๋ ๋น ๋ฅด๋ค.)
BufferedWriter๋ ์ผ๋ฐ์ ์ผ๋ก I/O ์์
์ผ๋ก ์ธํด ๋น๊ต์ ๋๋ฆด ์ ์๋ค.
๋ฐ๋ฉด์ StringBuilder๋ ๋ฌธ์์ด ์กฐ์์ ์ต์ ํ๋ ํด๋์ค๋ก, ๋ฌธ์์ด ์ฐ์ฐ์ ์ผ๋ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์์์ ์ํ๋๋ฏ๋ก ์๋์ ์ผ๋ก ๋น ๋ฅผ ์ ์๋ค.
๊ด๋ จ ํ์ด์ง
Leave a comment