๋ฌธ์
๋ณธ๊ฒฉ์ ์ผ๋ก for๋ฌธ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ ์ ์ฃผ์ํด์ผ ํ ์ ์ด ์๋ค. ์
์ถ๋ ฅ ๋ฐฉ์์ด ๋๋ฆฌ๋ฉด ์ฌ๋ฌ ์ค์ ์
๋ ฅ๋ฐ๊ฑฐ๋ ์ถ๋ ฅํ ๋ ์๊ฐ์ด๊ณผ๊ฐ ๋ ์ ์๋ค๋ ์ ์ด๋ค.
C++์ ์ฌ์ฉํ๊ณ ์๊ณ cin/cout์ ์ฌ์ฉํ๊ณ ์ ํ๋ค๋ฉด, cin.tie(NULL)๊ณผ sync_with_stdio(false)๋ฅผ ๋ ๋ค ์ ์ฉํด ์ฃผ๊ณ , endl ๋์ ๊ฐํ๋ฌธ์(\n)๋ฅผ ์ฐ์. ๋จ, ์ด๋ ๊ฒ ํ๋ฉด ๋ ์ด์ scanf/printf/puts/getchar/putchar ๋ฑ C์ ์
์ถ๋ ฅ ๋ฐฉ์์ ์ฌ์ฉํ๋ฉด ์ ๋๋ค.
Java๋ฅผ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, Scanner์ System.out.println ๋์ BufferedReader์ BufferedWriter๋ฅผ ์ฌ์ฉํ ์ ์๋ค. BufferedWriter.flush๋ ๋งจ ๋ง์ง๋ง์ ํ ๋ฒ๋ง ํ๋ฉด ๋๋ค.
Python์ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, input ๋์ sys.stdin.readline์ ์ฌ์ฉํ ์ ์๋ค. ๋จ, ์ด๋๋ ๋งจ ๋์ ๊ฐํ๋ฌธ์๊น์ง ๊ฐ์ด ์
๋ ฅ๋ฐ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ ์ ์ฅํ๊ณ ์ถ์ ๊ฒฝ์ฐ .rstrip()์ ์ถ๊ฐ๋ก ํด ์ฃผ๋ ๊ฒ์ด ์ข๋ค.
๋ํ ์
๋ ฅ๊ณผ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ณ๊ฐ์ด๋ฏ๋ก, ํ
์คํธ์ผ์ด์ค๋ฅผ ์ ๋ถ ์
๋ ฅ๋ฐ์์ ์ ์ฅํ ๋ค ์ ๋ถ ์ถ๋ ฅํ ํ์๋ ์๋ค. ํ
์คํธ์ผ์ด์ค๋ฅผ ํ๋ ๋ฐ์ ๋ค ํ๋ ์ถ๋ ฅํด๋ ๋๋ค.
์์ธํ ์ค๋ช
๋ฐ ๋ค๋ฅธ ์ธ์ด์ ๊ฒฝ์ฐ๋ ์ด ๊ธ์ ์ค๋ช
๋์ด ์๋ค.
์ด ๋ธ๋ก๊ทธ๊ธ์์ BOJ์ ๊ธฐํ ์ฌ๋ฌ ๊ฐ์ง ํ์ ๋ณผ ์ ์๋ค.
import java.util.Scanner;
public class Solution15552 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
int arr[] = new int[T];
for (int i=0; i<T; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
arr[i] = a + b;
}
sc.close();
for (int k : arr) {
System.out.println(k);
}
}
}
์ค์บ๋๋ก ํ์๋๋ฐ ์๊ฐ์ด๊ณผ๋ก ๋ฌธ์ ๊ฐ ํ๋ฆฌ์ง ์์๋ค..
๋๋์ด ์ฌ๊ฒ ์๋ค...
๋ญ๊ฐ ๊ธธ๊ณ ๋ณต์กํด์ ์ ์จ ๋ฌด์ํ๊ณ ์์๋ BufferReader๋ฅผ ๋ฌด์กฐ๊ฑด ์ฌ์ฉํด์ผํ๋ ๋ฌธ์ ๋ค.
์์ผ๋ก๋ ์์ฃผ ์ฌ์ฉํ ๊ฑฐ ๊ฐ์์ ๋จผ์ BufferReader/Writer๋ฅผ ๊ฒ์ํด ๋ณด์๋ค
๋๋ณด๊ธฐ
BufferedReader
:Scanner์ ์ ์ฌ.
โ
Bufferedwriter
:System.out.println();๊ณผ ์ ์ฌ
โ
๋์ ๋ชจ๋ ๊ธฐ์กด์ ์ฐ๋ scanner์ System.out.println()๋ณด๋ค ์๋ ์ธก๋ฉด์์ ํจ์ฌ ๋น ๋ฅด๊ธฐ ๋๋ฌธ์
(์
๋ ฅ๋ ๋ฐ์ดํฐ๊ฐ ๋ฐ๋ก ์ ๋ฌ๋์ง ์๊ณ ๋ฒํผ๋ฅผ ๊ฑฐ์ณ ์ ๋ฌ๋๋ฏ๋ก ๋ฐ์ดํฐ ์ฒ๋ฆฌ ํจ์จ์ฑ์ ๋์)
๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ๋ ์ ๋ฆฌํ๋ค.
โ
ํ์ง๋ง ๊ทธ์ ๋นํด BufferdReader์ Enter๋ง ๊ฒฝ๊ณ๋ก ์ธ์ํ๊ณ ๋ฐ์ ๋ฐ์ดํฐ๊ฐ String์ผ๋ก ๊ณ ์ ๋๊ธฐ ๋๋ฌธ์ ์
๋ ฅ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณตํ๋ ์์
์ด ํ์ํ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
<ํ์ํ import>
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
*BuffredReader ์ฌ์ฉ๋ฒ
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์ ์ธ
String s = br.readLine();
int i = Integer.parselnt(bf.readLine());
์ ์ธ์ ์์ ์๋ ์์ ์ฒ๋ผ ์งํํ๋ฉด ๋๋ค.
์
๋ ฅ์ readLine();์ด๋ผ๋ ๋ฉ์๋๋ฅผ ํ์ฉํ๋๋ฐ, ์ฌ๊ธฐ์ ๋ฐ๋์ ์ฃผ์ํด์ผํ ์ 2๊ฐ์ง๊ฐ ์๋ค.
์ฒซ๋ฒ์งธ๋ readLine()์ ๋ฆฌํด๊ฐ์ String์ผ๋ก ๊ณ ์ ๋๊ธฐ์ String์ด ์๋ ๋ค๋ฅธํ์
์ผ๋ก ์
๋ ฅ์ ๋ฐ์๋ ค๋ฉด ํ๋ณํ์ ๊ผญ ํด์ฃผ์ด์ผํ๋ค๋ ์ ์ด๋ค.
๋๋ฒ์งธ๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ๊ผญ ํด์ฃผ์ด์ผํ๋ค๋ ์ ์ด๋ค. readLine์ ํ ๋๋ง๋ค try & catch๋ฅผ ํ์ฉํ์ฌ ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ด๋ ๋์ง๋ง ๋๊ฐ throws IOException์ ํตํ์ฌ ์์
ํ๋ค.
โ
throw ์ด์ฉ ์
(1) ํด๋์ค๋ฅผ importํด์ฃผ์ด์ผ ํ๋ค.
import java.io.IOException;
(2) main ํด๋์ค ์์ throws IOException๋ฅผ ์์ฑํ๋ค.
public static void main(String[] args) throws IOException {}
StringTokenizer st = new StringTokenizer(s); //StringTokenizer์ธ์๊ฐ์ ์
๋ ฅ ๋ฌธ์์ด ๋ฃ์
int a = Integer.parseInt(st.nextToken()); //์ฒซ๋ฒ์งธ ํธ์ถ
int b = Integer.parseInt(st.nextToken()); //๋๋ฒ์งธ ํธ์ถ
String array[] = s.split(" "); //๊ณต๋ฐฑ๋ง๋ค ๋ฐ์ดํฐ ๋์ด์ ๋ฐฐ์ด์ ๋ฃ์
Readํ ๋ฐ์ดํฐ๋ Line๋จ์๋ก๋ง ๋๋ ์ง๊ธฐ์ ๊ณต๋ฐฑ๋จ์๋ก ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณตํ๋ ค๋ฉด ๋ฐ๋ก ์์
์ ํด์ฃผ์ด์ผํ๋๋ฐ, ์์ ๋๊ฐ์ง ๋ฐฉ๋ฒ์ด ๋ํ์ ์ด๋ค.
์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ์ผ๋ก๋ StringTokenizer์ nextToken()ํจ์๋ฅผ ์ฐ๋ฉด readLine()์ ํตํด ์
๋ ฅ๋ฐ์ ๊ฐ์ ๊ณต๋ฐฑ๋จ์๋ก ๊ตฌ๋ถํ์ฌ ์์๋๋ก ํธ์ถํ ์ ์๋ค.
๋๋ฒ์งธ ๋ฐฉ๋ฒ์ผ๋ก๋ String.split()ํจ์๋ฅผ ํ์ฉํ์ฌ ๋ฐฐ์ด์ ๊ณต๋ฐฑ๋จ์๋ก ๋์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ์ฌ์ฉํ๋ ๋ฐฉ์์ด๋ค
*BufferedWriter์ฌ์ฉ
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); //ํ ๋น๋ ๋ฒํผ์ ๊ฐ ๋ฃ์ด์ฃผ๊ธฐ
String s = "abcdefg"; //์ถ๋ ฅํ ๋ฌธ์์ด
bw.write(s+"\n"); //๋ฒํผ์ ์๋ ๊ฐ ์ ๋ถ ์ถ๋ ฅ
bw.flush(); //๋จ์์๋ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ์ถ๋ ฅ์ํด
bw.close(); //์คํธ๋ฆผ์ ๋ซ์
BufferedWriter ์ ๊ฒฝ์ฐ ๋ฒํผ๋ฅผ ์ก์ ๋์๊ธฐ ๋๋ฌธ์ ๋ฐ๋์ flush() / close() ๋ฅผ ๋ฐ๋์ ํธ์ถํด ์ฃผ์ด ๋ค์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ด์ผ ํ๋ค.
๊ทธ๋ฆฌ๊ณ bw.write์๋ System.out.println();๊ณผ ๊ฐ์ด ์๋๊ฐํ๊ธฐ๋ฅ์ด ์๊ธฐ๋๋ฌธ์ ๊ฐํ์ ํด์ฃผ์ด์ผํ ๊ฒฝ์ฐ์๋ \n๋ฅผ ํตํด ๋ฐ๋ก ์ฒ๋ฆฌํด์ฃผ์ด์ผ ํ๋ค.
โ
์์ ๋ด์ฉ์ ๋ณด๊ณ ๋ค์ BufferedReader/Writer๋ฅผ ์ฌ์ฉํด์ ๋ค์ ํด๋ณธ๊ฒฐ๊ณผ..
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
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));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st;
int T = Integer.parseInt(br.readLine());
for(int i=0; i<T; i++) {
st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
// bw.write((Integer.parseInt(st.nextToken(a))+Integer.parseInt(st.nextToken(b)))+"\n");
bw.write(a+b+"\n");
}
bw.close();
}
}
์๋ก์ด ๋ด์ฉ์ ๊ณต๋ถํ๊ณ ์ดํดํ๊ณ ๋ค์ ์ ์ฉํด๋ณด๊ณ ์์ ํ๊ณ ๋ฅผ ๊ณ์ํ๋ค๋ณด๋ ์๊ฐ์ด ํ์๊ฐ์ด ๋๊ฒ ๊ฑธ๋ ธ๋ค..
์ด๊ฑฐ ํ๋ ์ดํดํ๋๋ฐ ์ด๋ ๊ฒ ์ค๋ ๊ฑธ๋ ค์ ์ธ์ ๋๊ณ ํ ๋๊ฐ ๋ชจ๋ฅด๊ฒ ์ง๋ง ๋ด์ผ ๋ํด์ผ์ง ๋ญ ๐ช๐ช๐ช
๊ฐ๋
์ ์๊ฑฐ๊ฐ์๋ฐ ์ ์ฉ์ด ์ด๋ ค์์, ์์ผ๋ก ์์ ์ถ๋ ฅ ๋ฌธ์ ๋ค์ Scanner๋ฟ๋ง ์๋๋ผ BufferedReader/Writer๋ ์ฌ์ฉํ๋ ์ฐ์ต์ ํด์ผํ ๊ฒ ๊ฐ๋ค.. ์์ข์ข~