์์์๋ ๋งค๋
๋ฌ๋ฆฌ๊ธฐ ๊ฒฝ์ฃผ๊ฐ ์ด๋ฆฝ๋๋ค. ํด์ค์ง๋ค์ ์ ์๋ค์ด ์๊ธฐ ๋ฐ๋ก ์์ ์ ์๋ฅผ ์ถ์ํ ๋ ์ถ์ํ ์ ์์ ์ด๋ฆ์ ๋ถ๋ฆ
๋๋ค. ์๋ฅผ ๋ค์ด 1๋ฑ๋ถํฐ 3๋ฑ๊น์ง "mumu", "soe", "poe"
์ ์๋ค์ด ์์๋๋ก ๋ฌ๋ฆฌ๊ณ ์์ ๋, ํด์ค์ง์ด "soe"
์ ์๋ฅผ ๋ถ๋ ๋ค๋ฉด 2๋ฑ์ธ "soe"
์ ์๊ฐ 1๋ฑ์ธ "mumu"
์ ์๋ฅผ ์ถ์ํ๋ค๋ ๊ฒ์
๋๋ค. ์ฆ "soe"
์ ์๊ฐ 1๋ฑ, "mumu"
์ ์๊ฐ 2๋ฑ์ผ๋ก ๋ฐ๋๋๋ค.
์ ์๋ค์ ์ด๋ฆ์ด 1๋ฑ๋ถํฐ ํ์ฌ ๋ฑ์ ์์๋๋ก ๋ด๊ธด ๋ฌธ์์ด ๋ฐฐ์ด players
์ ํด์ค์ง์ด ๋ถ๋ฅธ ์ด๋ฆ์ ๋ด์ ๋ฌธ์์ด ๋ฐฐ์ด callings
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฒฝ์ฃผ๊ฐ ๋๋ฌ์ ๋ ์ ์๋ค์ ์ด๋ฆ์ 1๋ฑ๋ถํฐ ๋ฑ์ ์์๋๋ก ๋ฐฐ์ด์ ๋ด์ return ํ๋ solution
ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
players
์ ๊ธธ์ด โค 50,000players[i]
๋ i๋ฒ์งธ ์ ์์ ์ด๋ฆ์ ์๋ฏธํฉ๋๋ค.players
์ ์์๋ค์ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.players
์๋ ์ค๋ณต๋ ๊ฐ์ด ๋ค์ด๊ฐ ์์ง ์์ต๋๋ค.players[i]
์ ๊ธธ์ด โค 10callings
์ ๊ธธ์ด โค 1,000,000callings
๋ players
์ ์์๋ค๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.players | callings | result |
---|---|---|
["mumu", "soe", "poe", "kai", "mine"] | ["kai", "kai", "mine", "mine"] | ["mumu", "kai", "mine", "soe", "poe"] |
4๋ฑ์ธ "kai"
์ ์๊ฐ 2๋ฒ ์ถ์ํ์ฌ 2๋ฑ์ด ๋๊ณ ์์ 3๋ฑ, 2๋ฑ์ธ "poe"
, "soe"
์ ์๋ 4๋ฑ, 3๋ฑ์ด ๋ฉ๋๋ค. 5๋ฑ์ธ "mine"
์ ์๊ฐ 2๋ฒ ์ถ์ํ์ฌ 4๋ฑ, 3๋ฑ์ธ "poe"
, "soe"
์ ์๊ฐ 5๋ฑ, 4๋ฑ์ด ๋๊ณ ๊ฒฝ์ฃผ๊ฐ ๋๋ฉ๋๋ค. 1๋ฑ๋ถํฐ ๋ฐฐ์ด์ ๋ด์ผ๋ฉด ["mumu", "kai", "mine", "soe", "poe"]
์ด ๋ฉ๋๋ค.
class Solution {
public String[] solution(String[] players, String[] callings) {
for (String called : callings) {
for (int i = 1; i < players.length; i++) {
if (players[i].equals(called)) {
String temp = players[i - 1];
players[i - 1] = players[i];
players[i] = temp;
}
}
}
return players;
}
}
์ด์ค for๋ฌธ์ ์ฌ์ฉํ๋ ์ญ์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ์๋ค.
ํ์ ์๊ฐ์ ๋จ์ถ์ํค๊ธฐ ์ํด HashMap
์ ์ฌ์ฉํด๋ณด๊ธฐ๋ก ํ๋ค.
import java.util.*;
class Solution {
public String[] solution(String[] players, String[] callings) {
HashMap<String, Integer> ranking = new HashMap<>();
// ์ด๊ธฐ ์์ ๋ฐ์ดํฐ ์ ์ฅ
for (int i = 0; i < players.length; i++) {
ranking.put(players[i], i);
}
for (String called : callings) {
// ์ด๋ฆ์ด ๋ถ๋ฆฐ ์ ์ ์ธ๋ฑ์ค ์ถ์ถ
int calledRank = ranking.get(called);
// players ๋ฐฐ์ด์์ ์์ ๋ณ๊ฒฝ
String catched = players[calledRank - 1];
players[calledRank - 1] = players[calledRank];
players[calledRank] = catched;
// HashMap ์์ ์
๋ฐ์ดํธ
ranking.put(catched, ranking.get(catched) + 1);
ranking.put(called, ranking.get(called) - 1);
}
return players;
}
}
์ ์ ์ด๋ฆ๊ณผ ๋ฑ์๋ฅผ key-value๋ก ๊ฐ์ง๋ HashMap์ ํ๋ ์์ฑํด์ค ํ, ์ด๊ธฐ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํด ์ฃผ์๋ค.
callings
๋ฐฐ์ด์ ํ๋์ฉ ์ํํ๋ฉด์, ์ด๋ฆ์ด ๋ถ๋ฆฐ ์ ์์ ์ธ๋ฑ์ค๋ฅผ HashMap์ผ๋ก๋ถํฐ ๊ฐ์ ธ์ players
๋ฐฐ์ด์ ์์๋ฅผ ๋จผ์ ๋ฐ๊พธ์ด ์ฃผ์๋ค.
๋ง์ง๋ง์ผ๋ก HashMap์์ ๋ฐ๋ผ ์กํ ์ฌ๋์ value(๋ฑ์)์ 1์ ๋ํด์ฃผ๊ณ ,
๋ฐ๋ผ ์ก์ ์ฌ๋์ value(๋ฑ์)์ 1์ ๋นผ์ฃผ๋ฉด,
ํ์ฌ ์์๊ฐ ์
๋ฐ์ดํธ ๋จ์ผ๋ก์จ, ์์ ๊ต์ฒด ์์
์ด ๋๋๊ฒ ๋๋ค.
HashMap์ ์ฌ์ฉํจ์ผ๋ก์จ, key(์ ์ ์ด๋ฆ)๊ฐ์ ๋ํ value(๋ฑ์)๋ฅผ ํ์ํ๋ ์๊ฐ์ ํ๊ท ์ ์๊ฐ ๋ณต์ก๋๋ก ์ค์ผ ์ ์์ด์ ์๊ฐ ์ด๊ณผ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์๋ค.๐
๐๐๐๋ฌ๋ ค๋ผ ๋ฌ๋ ท...!