โค๏ธ ๋ฌธ์ ์ค๋ช
์๋ง์ ๋ง๋ผํค ์ ์๋ค์ด ๋ง๋ผํค์ ์ฐธ์ฌํ์์ต๋๋ค. ๋จ ํ ๋ช ์ ์ ์๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ์ ์๊ฐ ๋ง๋ผํค์ ์์ฃผํ์์ต๋๋ค.
๋ง๋ผํค์ ์ฐธ์ฌํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด participant์ ์์ฃผํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด completion์ด ์ฃผ์ด์ง ๋, ์์ฃผํ์ง ๋ชปํ ์ ์์ ์ด๋ฆ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ์ฌํญ
- ๋ง๋ผํค ๊ฒฝ๊ธฐ์ ์ฐธ์ฌํ ์ ์์ ์๋ 1๋ช ์ด์ 100,000๋ช ์ดํ์ ๋๋ค.
- completion์ ๊ธธ์ด๋ participant์ ๊ธธ์ด๋ณด๋ค 1 ์์ต๋๋ค.
- ์ฐธ๊ฐ์์ ์ด๋ฆ์ 1๊ฐ ์ด์ 20๊ฐ ์ดํ์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์ฐธ๊ฐ์ ์ค์๋ ๋๋ช ์ด์ธ์ด ์์ ์ ์์ต๋๋ค.
๐ ์ ์ถ๋ ฅ ์
โ์์ #1
"leo"๋ ์ฐธ์ฌ์ ๋ช
๋จ์๋ ์์ง๋ง, ์์ฃผ์ ๋ช
๋จ์๋ ์๊ธฐ ๋๋ฌธ์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
์์ #2
"vinko"๋ ์ฐธ์ฌ์ ๋ช
๋จ์๋ ์์ง๋ง, ์์ฃผ์ ๋ช
๋จ์๋ ์๊ธฐ ๋๋ฌธ์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
์์ #3
"mislav"๋ ์ฐธ์ฌ์ ๋ช
๋จ์๋ ๋ ๋ช
์ด ์์ง๋ง, ์์ฃผ์ ๋ช
๋จ์๋ ํ ๋ช
๋ฐ์ ์๊ธฐ ๋๋ฌธ์ ํ๋ช
์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
๐ ํ์ด
[LOOP ๋ฐฉ์]
- ๋ ๊ฐ์ ๋ฐฐ์ด : participant N๋ช ์ ์ฐธ๊ฐ์ ์ด๋ฆ, completion N-1๋ช ์ ์์ฃผ์๋ค
- ๋ ๋ฐฐ์ด์ ์ ๋ ฌ ํ ํ for๋ฌธ์ ๋๋ ค์ ๋น๊ตํ์ ๋ ์ผ์นํ์ง ์๋ ๊ฐ์ ์ฐพ์ผ๋ฉด ๋๋ค๊ณ ์๊ฐํ๋ค.
- ๋ฐฐ์ด์ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ ์์ฐจ์ ์ผ๋ก ๋๋ฆฌ๋ฉด์ ๋ฌธ์์ด์ ๋น๊ตํ๋๋ฐ, participant[i]๊ฐ๊ณ completion[i]๊ฐ์ด ์ผ์นํ์ง ์๋ ๋ถ๋ถ์์ ์ฐธ๊ฐ์๋ฅผ return ํด ์ฃผ๋ฉด ๋๋ค.
- ๋ฌธ์์ด ๋ถ์ ๋น๊ต๋ !๋น๊ต๋์1.equals(๋น๊ต๋์2)
- ๋ฐฐ์ด์ ๋ชจ๋ ์ํ ํ๋๋ฐ๋ ์ผ์นํ๋ ๊ฐ์ด ์๋ค๋ฉด participant์ ๋ง์ง๋ง ์ธ๋ฑ์ค์ ๋ด๊ธด ์ฌ๋์ด ๋ฏธ์์ฃผ์์ด๋ค.
import java.util.Arrays;
class Solution {
public String solution(String[] participant, String[] completion) {
// 1. ๋ฐฐ์ด ์ ๋ ฌ
Arrays.sort(participant);
Arrays.sort(completion);
// 2. for๋ฌธ ๋๋ ค์ ๋ฐฐ์ด ๋น๊ต
int i;
for (i = 0; i < completion.length; i++) {
if (!participant[i].equals(completion[i])){
return participant[i];
}
}
// 3. ๋ง์ง๋ง ์ฃผ์๊ฐ ์์ฃผํ์ง ๋ชปํ ๊ฒฝ์ฐ
return participant[i];
}
}
[HashMap ๋ฐฉ์]
ํ์ง๋ง ์ด ๋ฌธ์ ์ ์นดํ ๊ณ ๋ฆฌ๋ ํด์.
๋ช ์์ด ํด์๋ฌธ์ ์ธ ๋งํผ ํด์๋ก ํธ๋ ์ฝ๋๋ ์ง ๋ณผ ์ ์๋ค.
HashMap์ ์๊ฐ๋ณต์ก๋ ๋ฉด์์ Loop๋ณด๋ค ํจ์ฌ ์ ๋ฆฌํ๊ณ , ๋๋์ ๋ฐ์ดํฐ ํ์์ ์ ํฉํ๋ค.
ํค,๊ฐ ์์ ๊ฐ๊ธฐ ๋๋ฌธ์ Loop๋ฅผ ์ํํ์ง ์๊ณ ํค๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๊ณ ์ ์ฅํจ.
Loop์ ์๊ฐ๋ณต์ก๋๋ O(n), ํด์๋ O(1)๋ก ๋ฐ์ดํฐ๊ฐ ๋ง์ ์๋ก ์ ๊ทผ ์๋ ์ธก๋ฉด์์ ์ ๋ฆฌํ๋ค.
- ์ฐธ๊ฐ์ ๋ฐฐ์ด๋ก ํด์๋งต ๊ตฌ์ฑ : ์ฐธ๊ฐ์์ ์ด๋ฆ์ ํค(key)๋ก, ์ด๋ฆ์ด ๋ฑ์ฅํ ๋น๋์(count)๋ฅผ ๊ฐ์ผ๋ก ๋งคํ
- ์์ฃผ์ ๋ฐฐ์ด ์ํํ๋ฉด์ ํด์๋งต์์ 1๊ฐ์ ๊ฐ์
- ๊ฐ์ด 0์ด ์๋ ํค๊ฐ ์์ฃผํ์ง ๋ชปํ ์ฐธ๊ฐ์์ ์ด๋ฆ
import java.util.HashMap;
class Solution {
public String solution(String[] participant, String[] completion) {
HashMap<String, Integer> map = new HashMap<>();
// 1. ์ฐธ๊ฐ์ ๋ฐฐ์ด๋ก ํด์๋งต์ ๊ตฌ์ฑ
for (String p : participant) {
map.put(p, map.getOrDefault(p, 0) + 1); // ์ฐธ๊ฐ์ ์ด๋ฆ์ ํค๋ก, ์นด์ดํธ๋ฅผ ๊ฐ์ผ๋ก ์ ์ฅ
}
// 2. ์์ฃผ์ ๋ฐฐ์ด์ ์ํํ๋ฉด์ ํด์๋งต์์ ๊ฐ์ ๊ฐ์
for (String c : completion) {
map.put(c, map.get(c) - 1); // ์์ฃผ์์ ํด๋นํ๋ ์ด๋ฆ์ ๊ฐ์ 1์ฉ ๊ฐ์
}
// 3. ๊ฐ์ด 0์ด ์๋ ํค๊ฐ ์์ฃผํ์ง ๋ชปํ ์ฐธ๊ฐ์
for (String key : map.keySet()) {
if (map.get(key) != 0) {
return key; // ๊ฐ์ด 0์ด ์๋ ์ฐธ๊ฐ์ ์ด๋ฆ์ ๋ฐํ
}
}
return ""; // ์กฐ๊ฑด์ ๋ง๋ ์ฐธ๊ฐ์๋ฅผ ์ฐพ์ง ๋ชปํ ๊ฒฝ์ฐ(์ผ๋ฐ์ ์ผ๋ก๋ ๋ฐ์ํ์ง ์์)
}
}
map์ด๋ผ๋ ์ด๋ฆ์ ํด์๋งต ๋ง๋ค๊ธฐ
map.put(p, map.getOrDefault(p, 0) + 1);
put ๋ฉ์๋๋ก ํด์๋งต์ ์๋ก์ด ํค-๊ฐ ์์ ์ถ๊ฐ
participant ๋ฐฐ์ด์ ๊ฐ ์ด๋ฆ(p)์ ํค๋ก ์ถ๊ฐํ๊ณ , ํด๋น ์ด๋ฆ์ด ํด์๋งต์ ์๋ค๋ฉด ์ด๊ธฐ๊ฐ์ผ๋ก 0์ ์ค์ . ์์ผ๋ฉด 1์ฉ ๋ํด์ฃผ๊ธฐ
๊ฐ ์ฐธ๊ฐ์ ์ด๋ฆ์ด ํค, ์ด๋ฆ ์ถํ ๋น๋๊ฐ ๊ฐ์ด ๋จ
map.put(c, map.get(c) - 1);
ํด์๋งต์์ ์์ฃผ์์ ํด๋นํ๋ ์ด๋ฆ์ ๊ฐ์ 1์ฉ ๊ฐ์
map.keySet()์ผ๋ก ํด์๋งต์ ์๋ ๋ชจ๋ ํค๊ฐ์ ๋ํด ์๋ ์์ ์ ๋ฐ๋ณตํ๋๋ฐ
ํ์ฌ ํค์ ๋ํ ๊ฐ์ ๊ฐ์ ธ์์ ๊ทธ ๊ฐ์ด 0์ด ์๋์ง๋ฅผ ์ฒดํฌํ๋ค.
์ฌ๊ธฐ์ ๊ฐ์ ๊ทธ ์ฐธ๊ฐ์๊ฐ ๋ช ๋ฒ ์ฐธ๊ฐํ๋์ง๋ฅผ ๋ํ๋ด๋๋ฐ, ๋ง์ฝ ๊ฐ์ด 0์ด๋ผ๋ฉด ํด๋น ์ฐธ๊ฐ์๋ ์์ฃผํ์์ ์๋ฏธ
๋ฐ๋๋ก, ๊ฐ์ด 0์ด ์๋๋ผ๋ฉด ๊ทธ ์ฐธ๊ฐ์๋ ์์ฃผํ์ง ๋ชปํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๊ฐ์ด 0์ด ์๋ ํค๊ฐ ๋ฏธ์์ฃผ์์ ์ด๋ฆ์ด ๋๋ค.