[BaekJoon] 3046๋ฒ - R2 (java)
1. ๋ฌธ์
๐ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
- ์กฐ๊ฑด
์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ |
---|---|
1์ด | 128MB |
- ๋ฌธ์
๋ ์ซ์ R1๊ณผ R2๊ฐ ์์ ๋, ๋ ์์ ํ๊ท S๋ (R1+R2)/2์ ๊ฐ๋ค. ์๊ทผ์ด๋ ์ ์ธ์ด ์์ผ ์ ๋ฌผ๋ก ๋ ์ซ์ R1๊ณผ R2๋ฅผ ์ฃผ๋ ค๊ณ ํ๋ค. ์์ผ ํํฐ์์ ์๊ทผ์ด๋ ์ ์ธ์ด์๊ฒ ์ด ๋ ์ซ์๋ฅผ ๋งํด์ฃผ๊ณ , ์ ์ธ์ด๋ ์ด ์ซ์๋ฅผ ๋ฐ์ ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ๊ธฐ์ ๋ง์์ผ๋ก 1๋
๋์ ์ด ์ซ์๋ฅผ ์ธ์ฐ๋ฉด์ ์ฐ๋ค.
์๊ทผ์ด๋ R1๊ณผ R2๋ฅผ ์์ฒญ๋ ๊ณ ๋ฏผ ๋์ ์ ํ๋ค. ์๋
์๋ R1๊ณผ R2๋ฅผ ๊น๋จน์ด์ ์๋ฌด ์ซ์๋ ์ ํด์ ์ฃผ์๊ธฐ ๋๋ฌธ์, ์ฌํด๋ ๊น๋จน์ง ์๊ธฐ ์ํด์ ํ๊ท S๋ ๊ฐ์ด ๊ธฐ์ตํ๋ ค๊ณ ํ๋ค.
์ค๋์ ์ ์ธ์ด ์์ผ์ด๋ค. 5๋ถ ํ์ ์๊ทผ์ด๋ ์์ผ ์ ๋ฌผ๋ก ๋ ์ซ์ R1๊ณผ R2๋ฅผ ๋งํด์ฃผ์ด์ผ ํ์ง๋ง, ์ํ๊น๊ฒ๋ R2๋ฅผ ๊น๋จน๊ณ ๋ง์๋ค. ํ์ง๋ง R1๊ณผ S๋ ๊ธฐ์ตํ๊ณ ์๋ค!
์๊ทผ์ด๋ฅผ ๋์ R2๊ฐ ๋ช ์ธ์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ ์ ์ R1๊ณผ S๊ฐ ์ฃผ์ด์ง๋ค. ๋ ์๋ -1000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 1000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
- ์ถ๋ ฅ
์ฒซ์งธ ์ค์ R2๋ฅผ ์ถ๋ ฅํ๋ค.
- ์์
ย ย ์ ๋ ฅย ย | ย ย ์ถ๋ ฅย ย |
---|---|
11 15 | 19 |
4 3 | 2 |
2. ํ์ด
2๊ฐ์ ์ ๋ ฅ๋ฐฉ์์ ์ฌ์ฉํด์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
- Scanner ํด๋์ค
- BufferedReader ํด๋์ค
2-1. Scanner ํด๋์ค
import java.util.Scanner;
public class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int R1 = sc.nextInt();
int S = sc.nextInt();
int R2 = S*2 - R1;
System.out.println(R2);
}
}
์์๊ฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋, Scanner(System.in) ์์
System.in
์ ์ ๋ ฅํ ๊ฐ์Byte ๋จ์
๋ก ์ฝ๋ ๊ฒ์ ๋ปํ๋ค.
intํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด
nextInt()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
2-2. BufferedReader ํด๋์ค ์ฌ์ฉ
BufferedReader๋ readLine()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด ํ ํ์ ์ ๋ถ ์ฝ๋๋ค.
์ด๋ฅผ ๊ณต๋ฐฑ๋จ์๋ก ๋ถ๋ฆฌํด์ผ ํ๋๋ฐ, ๋๊ฐ์ง ๋ถ๋ฆฌ ๋ฐฉ๋ฒ์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์.
ย ย ย ย โ StringTokenizer ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ถ๋ฆฌํด์ฃผ๋ ๋ฐฉ๋ฒ
ย ย ย ย โก split() ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
โ StringTokenizer ํด๋์ค๋ฅผ ์ด์ฉ
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));
StringTokenizer st = new StringTokenizer(br.readLine()," ");
int R1 = Integer.parseInt(st.nextToken());
int S = Integer.parseInt(st.nextToken());
int R2 = S*2 - R1;
System.out.println(R2);
}
}
readLine()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ ๋ ฅ๋ฐ์ ๊ฐ์ ํ ์ค ํต์งธ๋ก ์ฝ์ด String ์ผ๋ก ๋ฐํํ๋ค.
Integer.parseInt()
์ ์ฌ์ฉํด Stringํ์intํ์ผ๋ก ๋ณํ
์์ผ์ค๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
BufferedReader ํด๋์ค
์ ๋ํด ๋ ์์๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ฅผ ํด๋ฆญํ๋ฉด ๋๋ค.โ split() ๋ฉ์๋ ์ด์ฉ
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main{
public static void main(String args[]) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] arr = br.readLine().split(" ");
int R1 = Integer.parseInt(arr[0]);
int S = Integer.parseInt(arr[1]);
int R2 = S*2 - R1;
System.out.println(R2);
}
}
split()
์ ์ฌ์ฉํด readLine() ์ผ๋ก ์ ๋ ฅ๋ฐ์ ๊ฐ์๊ณต๋ฐฑ(" ") ๊ธฐ์ค์ผ๋ก
๋๋์ดString ๋ฐฐ์ด์ ์ ์ฅ
ํ๋ค.
3. Scanner VS BufferedReader ์ฑ๋ฅ ๋น๊ต
์์์ ๋ถํฐ ์์๋๋ก
BufferedReader + StringTokenizer
BufferedReader + split()
Scanner
์ ๋ ฅ์ ๊ฒฝ์ฐ ํ์คํ Scanner ๋ณด๋ค๋ BufferedReader ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
๊ด๋ จ ํ์ด์ง
Leave a comment