โญ๏ธ 5597 ๊ณผ์ ์ ๋ด์ ๋ถ..?
๋ฌธ์
X๋ํ M๊ต์๋์ ํ๋ก๊ทธ๋๋ฐ ์์ ์ ๋งก๊ณ ์๋ค. ๊ต์ค์ ํ์์ด 30๋ช ์ด ์๋๋ฐ, ํ์ ๋ช ๋ถ์ ๊ฐ ํ์๋ณ๋ก 1๋ฒ๋ถํฐ 30๋ฒ๊น์ง ์ถ์๋ฒํธ๊ฐ ๋ถ์ด ์๋ค.
๊ต์๋์ด ๋ด์ค ํน๋ณ๊ณผ์ ๋ฅผ 28๋ช ์ด ์ ์ถํ๋๋ฐ, ๊ทธ ์ค์์ ์ ์ถ ์ ํ ํ์ 2๋ช ์ ์ถ์๋ฒํธ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ ๋ ฅ์ ์ด 28์ค๋ก ๊ฐ ์ ์ถ์(ํ์)์ ์ถ์๋ฒํธ n(1 ≤ n ≤ 30)๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ถ์๋ฒํธ์ ์ค๋ณต์ ์๋ค.
// ์๋ต. 1๋ถํฐ 30๊น์ง์ ์ซ์์ค 28๊ฐ์ ๋๋ค ์ซ์๋ค์ด ์๋ค.
์ถ๋ ฅ
์ถ๋ ฅ์ 2์ค์ด๋ค. 1๋ฒ์งธ ์ค์ ์ ์ถํ์ง ์์ ํ์์ ์ถ์๋ฒํธ ์ค ๊ฐ์ฅ ์์ ๊ฒ์ ์ถ๋ ฅํ๊ณ , 2๋ฒ์งธ ์ค์์ ๊ทธ ๋ค์ ์ถ์๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
2
8
// ์ ์์์ ์๋ ์ซ์๊ฐ ์ถ๋ ฅ๋๋ค.
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] student = new int[30];
for (int n = 0; n < 28; n++){
int k = Integer.parseInt(br.readLine());
student[k-1] = k;
}
for (int n = 0; n < 30; n++){
if (student[n] == 0){
System.out.println(n+1);
}
}
}
}
30๋งํผ์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ ์ ์ฒด ํ์์ ๋ฐฐ์ด student์ ๋ง๋ค๊ณ ,
์ ์ถํ ํ์์ 28๋ช ์ด๋ผ๊ณ ๊ณ ์ ๋์ด์์ผ๋ฏ๋ก , 28๋ฒ for๋ฌธ์ ๋๋ค.
์ ๋ ฅ๋ฐ์ ํ์ ๋ฒํธ๋ฅผ ์ธ๋ฑ์ค๋กํ์ฌ, student ๋ฐฐ์ด์ ๊ฐ์ ์ฑ์ด๋ค.
๋ง์ฝ ๋ฐฐ์ด์ ๊ฐ์ด 0์ด๋ฉด ์ ์ถ์ ์ํ ํ์์ด๋ฏ๋ก
์ด ์ธ๋ฑ์ค๋ฅผ ์ถ๋ ฅํ๋๋ก ํ๋ค.
3052 ๋๋จธ์ง
๋ฌธ์
๋ ์์ฐ์ A์ B๊ฐ ์์ ๋, A%B๋ A๋ฅผ B๋ก ๋๋ ๋๋จธ์ง ์ด๋ค. ์๋ฅผ ๋ค์ด, 7, 14, 27, 38์ 3์ผ๋ก ๋๋ ๋๋จธ์ง๋ 1, 2, 0, 2์ด๋ค.
์ 10๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ค, ์ด๋ฅผ 42๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค. ๊ทธ ๋ค์ ์๋ก ๋ค๋ฅธ ๊ฐ์ด ๋ช ๊ฐ ์๋์ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค๋ถํฐ ์ด๋ฒ์งธ ์ค ๊น์ง ์ซ์๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ด ์ซ์๋ 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๊ณ , ์์ด ์๋ ์ ์์ด๋ค.
42
84
252
420
840
126
42
84
420
126
์ถ๋ ฅ
์ฒซ์งธ ์ค์, 42๋ก ๋๋์์ ๋, ์๋ก ๋ค๋ฅธ ๋๋จธ์ง๊ฐ ๋ช ๊ฐ ์๋์ง ์ถ๋ ฅํ๋ค.
1
๊ทธ๋ฅ ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ,
๊ทธ ์ ๊ฑฐ๋ ๋ฆฌ์คํธ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ฉด ๋๋ค๊ณ ์๊ฐํ๋ค.
์ค๋ณต ์ ๊ฑฐ์๋ set์ ์ฌ์ฉํ๋ค.
import java.io.*;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Set<Integer> set = new HashSet<>();
for (int i = 0; i < 10; i++) {
int N = Integer.parseInt(br.readLine());
set.add(N%42);
}
System.out.println(set.toArray().length);
}
}
1546 ํ๊ท
๋ฌธ์
์ธ์ค์ด๋ ๊ธฐ๋ง๊ณ ์ฌ๋ฅผ ๋ง์ณค๋ค. ์ธ์ค์ด๋ ์ ์๋ฅผ ์กฐ์ํด์ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ๋ก ํ๋ค. ์ผ๋จ ์ธ์ค์ด๋ ์๊ธฐ ์ ์ ์ค์ ์ต๋๊ฐ์ ๊ณจ๋๋ค. ์ด ๊ฐ์ M์ด๋ผ๊ณ ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ๋ชจ๋ ์ ์๋ฅผ ์ ์/M*100์ผ๋ก ๊ณ ์ณค๋ค.
์๋ฅผ ๋ค์ด, ์ธ์ค์ด์ ์ต๊ณ ์ ์ด 70์ด๊ณ , ์ํ์ ์๊ฐ 50์ด์์ผ๋ฉด ์ํ์ ์๋ 50/70*100์ด ๋์ด 71.43์ ์ด ๋๋ค.
์ธ์ค์ด์ ์ฑ์ ์ ์์ ๋ฐฉ๋ฒ๋๋ก ์๋ก ๊ณ์ฐํ์ ๋, ์๋ก์ด ํ๊ท ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ํ ๋ณธ ๊ณผ๋ชฉ์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. ์ด ๊ฐ์ 1000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. ๋์งธ ์ค์ ์ธ์ค์ด์ ํ์ฌ ์ฑ์ ์ด ์ฃผ์ด์ง๋ค. ์ด ๊ฐ์ 100๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ด ์๋ ์ ์์ด๊ณ , ์ ์ด๋ ํ๋์ ๊ฐ์ 0๋ณด๋ค ํฌ๋ค.
3
40 80 60
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์๋ก์ด ํ๊ท ์ ์ถ๋ ฅํ๋ค. ์ค์ ์ ๋ต๊ณผ ์ถ๋ ฅ๊ฐ์ ์ ๋์ค์ฐจ ๋๋ ์๋์ค์ฐจ๊ฐ 10-2 ์ดํ์ด๋ฉด ์ ๋ต์ด๋ค.
75.0
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.parseInt(br.readLine());
StringTokenizer st = new StringTokenizer(br.readLine());
int[] arr = new int[N];
double sum = 0.0;
double M = Integer.MIN_VALUE;
for (int i = 0; i < N; i++) {
arr[i] = Integer.parseInt(st.nextToken());
if (arr[i] > M) {
M = arr[i];
}
}
for (int i = 0; i < N; i++) {
sum += ((double)arr[i] / M) * 100;
}
System.out.println(sum/N);
}
}
์ค์ฐจ ๋ฒ์๋ฅผ ์ํด double์ ์ฌ์ฉํ๋ค.
double์ ์ฌ์ฉํ๋ ์ด์ ๋ ์๋์ ํฌ์คํ ํด๋์๋ค