โ ๋ฌธ์
์์์ฆ์ ์ ํ, ๊ตฌ๋งคํ ๊ฐ ๋ฌผ๊ฑด์ ๊ฐ๊ฒฉ & ๊ฐ์๊ตฌ๋งคํ ๋ฌผ๊ฑด๋ค์ ์ด ๊ธ์ก์ ๋ณด๊ณ , ๊ตฌ๋งคํ ๋ฌผ๊ฑด์ ๊ฐ๊ฒฉ๊ณผ ๊ฐ์๋ก ๊ณ์ฐํ ์ด ๊ธ์ก์ด ์์์ฆ์ ์ ํ ์ด ๊ธ์ก๊ณผ ์ผ์นํ๋์ง ๊ฒ์ฌํด๋ณด์.
โ๐ฅ ์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์์์ฆ์ ์ ํ ์ด ๊ธ์ก X๊ฐ ์ฃผ์ด์ง๋ค.
๋์งธ ์ค์๋ ์์์ฆ์ ์ ํ ๊ตฌ๋งคํ ๋ฌผ๊ฑด์ ์ข ๋ฅ์ ์ N์ด ์ฃผ์ด์ง๋ค.
์ดํ N๊ฐ์ ์ค์๋ ๊ฐ ๋ฌผ๊ฑด์ ๊ฐ๊ฒฉ a์ ๊ฐ์ b๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค.
โ๐ฅ ์ถ๋ ฅ
๊ตฌ๋งคํ ๋ฌผ๊ฑด์ ๊ฐ๊ฒฉ๊ณผ ๊ฐ์๋ก ๊ณ์ฐํ ์ด ๊ธ์ก์ด ์์์ฆ์ ์ ํ ์ด ๊ธ์ก๊ณผ ์ผ์นํ๋ฉด Yes๋ฅผ ์ถ๋ ฅํ๋ค.
์ผ์นํ์ง ์๋๋ค๋ฉด No๋ฅผ ์ถ๋ ฅํ๋ค.
โ
๐ก ํ์ด
๋ณ์ int x์ n์ ์ ์ธํ๊ณ ๊ตฌ๋งคํ ๋ฌผ๊ฑด์ ์ด ํฉ๊ณผ ์ข ๋ฅ ์๋ฅผ ์ ๋ ฅ ๋ฐ๋๋ค. ๊ทธ๋ฆฌ๊ณ ํฉ์ ๋์ ํด์ค ์ ์ํ ๋ณ์ int hap์ ์ ์ธํด์ฃผ์๋ค. ๋ฐ๋ณต๋ฌธ for๋ฌธ์ 0๋ถํฐ n๊น์ง 1์ฉ ์ฆ๊ฐํ๋ฉฐ ๋๋ ค์ฃผ๋๋ฐ, ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฌ๋ฉฐ ๋ฌผ๊ฑด์ ๊ฐ๊ฒฉ a์ ๋ฌผ๊ฑด์ ๊ฐฏ์ b๋ฅผ ์ ๋ ฅ๋ฐ๊ณ ๋ ๊ฐ์ง๋ฅผ ๊ณฑํด์ค ๋ค์ hap์ ๋์ ์์ผ ์ฃผ์๋ค.
for๋ฌธ์ ์ข ๋ฃํ ๋ค, if-else ์กฐ๊ฑด๋ฌธ์ผ๋ก x์ hap์ด ๊ฐ์ผ๋ฉด Yes๋ฅผ ์ถ๋ ฅํ๊ณ ์๋๋ผ๋ฉด No๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํด ์ค๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํ ์ !! ๋๋ฌธ์๋ก ์์ํ๋ค. ์๋ฐ๋ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ณํ๊ธฐ ๋๋ฌธ์ ๊ธ์ก์ด ์ผ์นํ๋ฉด Yes, ์๋๋ผ๋ฉด No๋ฅผ ์จ ์ฃผ์ด์ผ ํ๋ค. yes๋ no๋ก ์์ฑํ๋ฉด ํ๋ฆฐ ์ฝ๋๋ก ํ์ ๋๋ค
โ 1. Scanner ๋ก ์ ๋ ฅ๋ฐ๊ธฐ
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int n = sc.nextInt();
int hap = 0;
for(int i=0; i<n; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
hap += a*b;
}
if (x==hap) System.out.println("Yes");
else System.out.println("No");
}
}
โ 2. BufferedReader๋ก ์ ๋ ฅ ๋ฐ๊ธฐ
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// BufferedReader ๊ฐ์ฒด๋ฅผ ์์ฑ
StringTokenizer st = new StringTokenizer(br.readLine());
// BufferedReader๋ฅผ ์ฌ์ฉํ์ฌ ํ ์ค์ ์ฝ๊ณ ,
// ๊ทธ๊ฒ์ StringTokenizer๋ฅผ ์ฌ์ฉํ์ฌ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋ถ๋ฆฌ
int x = Integer.parseInt(st.nextToken());
int n = Integer.parseInt(st.nextToken());
// StringTokenizer์์ ์ฝ์ ๋ฌธ์์ด์ ์ ์๋ก ๋ณํํ์ฌ ๋ณ์ x์ n์ ์ ์ฅ
int hap = 0;
// hap ๋ณ์๋ฅผ ์ ์ธํ๊ณ 0์ผ๋ก ์ด๊ธฐํํฉ๋๋ค. hap์ ์ต์ข
๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ ๋ณ์
for (int i = 0; i < n; i++) {
st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
hap += a * b;
// hap ๋ณ์์ a์ b์ ๊ณฑ์ ๋์ (๋ชจ๋ ์
๋ ฅ ๊ฐ์ ๊ณฑ์ ๋์ )
}
if (x == hap)
System.out.println("Yes");
else
System.out.println("No");
}
}
์ด๋ณด์๋ค์ ๋น๊ต์ ์ฌ์ฉ์ด ๊ฐํธํ Scanner๋ฅผ ๋ง์ด ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ BufferedReader ๊ฐ์ฒด๋ฅผ ์ด์ฉํ๋ ๊ฒ์ ์ด๋ ค์ธ ์ ์๋ค. ๊ทธ๋์ BufferedReader ์ฌ์ฉ๋ฒ์ ๊ฐ๋จํ ์ค๋ช ํด ๋ณด์๋ฉด...
๋จผ์
BufferedReader ๊ฐ์ฒด๋ฅผ ์์ฑํด์ค๋ค. BufferedReader๋ ํ ์คํธ๋ฅผ ์ฝ๊ธฐ ์ํ ํด๋์ค์ด๊ณ , InputStreamReader๋ ๋ฐ์ดํธ ์คํธ๋ฆผ์ ๋ฌธ์ ์คํธ๋ฆผ์ผ๋ก ๋ณํํ๋ ํด๋์ค์ด๋ค. System.in์ ํ์ค ์ ๋ ฅ ์คํธ๋ฆผ์ธ๋ฐ, ์ฌ์ฉ์์ ์ ๋ ฅ์ ๋ฐ๋ ํค๋ณด๋ ์ ๋ ฅ์ ์๋ฏธํ๋ค. ๋ฐ๋ผ์ new InputStreamReader(System.in)์ ํค๋ณด๋ ์ ๋ ฅ์ ๋ฐ์๋ค์ด๋ ๋ฌธ์ ์คํธ๋ฆผ์ ์์ฑํ๊ณ , ์ด๋ฅผ ๋ค์ BufferedReader์ ์ ๋ฌํ์ฌ ๋ฒํผ๋ง๋ ์ ๋ ฅ ๊ธฐ๋ฅ์ ์ ๊ณตํ๊ฒ ๋๋ค. ๋ฒํผ๋ง์ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ์ฝ๊ฑฐ๋ ์ฐ๋ ๊ฒ๋ณด๋ค ์ฌ๋ฌ ๋ฒ ์์ ๋ฉ์ด๋ฆฌ๋ก ๋๋์ด์ ์ฝ๊ฑฐ๋ ์ฐ๋ ๊ฒ์ด ํจ์จ์ ์ผ ๋ ์ฌ์ฉ๋๋ค.
๋ฐ๋ผ์ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));์ ์ฌ์ฉ์์ ํค๋ณด๋ ์ ๋ ฅ์ ๋ฐ๊ธฐ ์ํ BufferedReader ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๊ณผ์ ์ด๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋์ค์ br.readLine()์ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์์ ์ ๋ ฅ์ ํ ์ค์ฉ ์ฝ์ด์ฌ ์ ์๋ค.
Scanner ๋์ BufferedReader๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฅ์ ๋ฐ์ผ๋ฉด StringTokenizer๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์ค์ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋์ด ์ฒ๋ฆฌํ๋ค.
'Algorithm > BaekJoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 15552๋ฒ ๋น ๋ฅธ A+B - ์๋ฐ / java (0) | 2024.04.15 |
---|---|
[๋ฐฑ์ค] 25314๋ฒ ์ฝ๋ฉ์ ์ฒด์ก๊ณผ๋ชฉ ์ ๋๋ค - ์๋ฐ / java (0) | 2024.04.12 |
[๋ฐฑ์ค] 8393๋ฒ ํฉ - ์๋ฐ / java (0) | 2024.04.12 |
[๋ฐฑ์ค] 10950๋ฒ A+B-3 ์๋ฐ / java (0) | 2024.04.11 |
[๋ฐฑ์ค] 2739๋ฒ ๊ตฌ๊ตฌ๋จ - ์๋ฐ / java (0) | 2024.04.11 |