2023. 2. 7. 13:56ใ์ฝ๋ฉํ ์คํธ ์ฐ์ต/ํ๋ก๊ทธ๋๋จธ์ค_2023
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด s๊ฐ ์ฃผ์ด์ก์ ๋, s์ ๊ฐ ์์น๋ง๋ค ์์ ๋ณด๋ค ์์ ๋์์ผ๋ฉด์, ์์ ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ณณ์ ์๋ ๊ฐ์ ๊ธ์๊ฐ ์ด๋ ์๋์ง ์๊ณ ์ถ์ต๋๋ค.
์๋ฅผ ๋ค์ด, s="banana"๋ผ๊ณ ํ ๋, ๊ฐ ๊ธ์๋ค์ ์ผ์ชฝ๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฝ์ด ๋๊ฐ๋ฉด์ ๋ค์๊ณผ ๊ฐ์ด ์งํํ ์ ์์ต๋๋ค.
- b๋ ์ฒ์ ๋์๊ธฐ ๋๋ฌธ์ ์์ ์ ์์ ๊ฐ์ ๊ธ์๊ฐ ์์ต๋๋ค. ์ด๋ -1๋ก ํํํฉ๋๋ค.
- a๋ ์ฒ์ ๋์๊ธฐ ๋๋ฌธ์ ์์ ์ ์์ ๊ฐ์ ๊ธ์๊ฐ ์์ต๋๋ค. ์ด๋ -1๋ก ํํํฉ๋๋ค.
- n์ ์ฒ์ ๋์๊ธฐ ๋๋ฌธ์ ์์ ์ ์์ ๊ฐ์ ๊ธ์๊ฐ ์์ต๋๋ค. ์ด๋ -1๋ก ํํํฉ๋๋ค.
- a๋ ์์ ๋ณด๋ค ๋ ์นธ ์์ a๊ฐ ์์ต๋๋ค. ์ด๋ 2๋ก ํํํฉ๋๋ค.
- n๋ ์์ ๋ณด๋ค ๋ ์นธ ์์ n์ด ์์ต๋๋ค. ์ด๋ 2๋ก ํํํฉ๋๋ค.
- a๋ ์์ ๋ณด๋ค ๋ ์นธ, ๋ค ์นธ ์์ a๊ฐ ์์ต๋๋ค. ์ด ์ค ๊ฐ๊น์ด ๊ฒ์ ๋ ์นธ ์์ด๊ณ , ์ด๋ 2๋ก ํํํฉ๋๋ค.
๋ฐ๋ผ์ ์ต์ข ๊ฒฐ๊ณผ๋ฌผ์ [-1, -1, -1, 2, 2, 2]๊ฐ ๋ฉ๋๋ค.
๋ฌธ์์ด s์ด ์ฃผ์ด์ง ๋, ์์ ๊ฐ์ด ์ ์๋ ์ฐ์ฐ์ ์ํํ๋ ํจ์ solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 1 ≤ s์ ๊ธธ์ด ≤ 10,000
- s์ ์์ด ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
"banana" | [-1, -1, -1, 2, 2, 2] |
"foobar" | [-1, -1, 1, -1, -1, -1] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
์ง๋ฌธ๊ณผ ๊ฐ์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
์ค๋ช
์๋ต
๋์ ํ์ด
public int[] solution(String s) {
int[] answer = new int[s.length()];
HashMap<String, Integer> map = new HashMap<>();
String[] split = s.split("");
for (int i = 0; i< split.length; i++)
{
Integer integer = map.get(split[i]);
if (integer == null) {
answer[i] = -1;
}else {
answer[i] = i - integer;
}
map.put(split[i], i);
}
return answer;
}
๋๋ ์ฐ์ HashMap์๋ค๊ฐ key ๊ฐ์ผ๋ก ์ฃผ์ด์ง ๋ฌธ์์ด์ ์ชผ๊ฐ ๊ฐ์ ๋ด๊ณ , ๊ทธ ๋ฌธ์์ด์ ์์น๋ฅผ ๋ด์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
์ฐ์ ๋ฌธ์์ด์ ์ชผ๊ฐ์ฃผ๊ณ , ๋ง์ฝ map์์ key ๋ก ๊บผ๋์ ๋ integer ๊ฐ null์ด๋ฉด ์ฒซ๋ฒ์งธ ๊ธ์๋ผ๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ answer ๋ฐฐ์ด์๋ -1์ ๋ฃ์ด์ฃผ๊ณ ,
๋ง์ฝ null ์ด ์๋๋ผ๋ฉด ์ฒซ๋ฒ์งธ ๊ธ์๊ฐ ์๋๋ผ๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ answer์ ์ชผ๊ฐ ๋ฌธ์์ด์ ์์น์ธ i์ map์์ ๊บผ๋ธ ์์น i๋ฅผ ๋บ ๊ฐ์ ๋ฃ์ด์คฌ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ง์ฝ banana์ฒ๋ผ a๊ฐ ๋๋ฒ์งธ, 4๋ฒ์งธ์ ์์นํ๊ณ ์๋ ๊ฒฝ์ฐ๋ฅผ ์ํด์ map์๋ ๋ง์ง๋ง ๊ฐ์ ๋ฃ์ด์ฃผ๋๋ก ํ๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
public int[] otherSolution(String s)
{
int[] answer = new int[s.length()];
HashMap<Character, Integer> map = new HashMap<>();
for (int i =0; i< s.length(); i++)
{
char c = s.charAt(i);
answer[i] = i - map.getOrDefault(c, i + 1);
map.put(c, i);
}
return answer;
}
๋๋ ๋ฐฉ์ HashMap์ ์ฌ์ฉํด์ ๋น์ทํ๊ฒ ํ๋๋ฐ Character๋ฅผ ์ฌ์ฉํด์ ํผ ํ์ด๊ฐ ์์ด์ ๊ฐ์ ธ์๋ค.
๊ทธ๋ฆฌ๊ณ ๋๋ getOrDefault๋ฅผ ๊ธฐ์ต ๋ชปํด์ ๋ถ๊ธฐ์ฒ๋ฆฌ๋ก ํ๋๋ฐ... ์ด๊ฑธ ์์๋๋ผ๋ฉด ๋ ๊ฐ๋จํ๊ฒ ํ ์ ์์์ ๊ฒ์ด๋ค ใ ใ
๐พ getOrDefault (key, DefaultValue)
: ์ฐพ๋ ํค๊ฐ ์กด์ฌํ๋ค๋ฉด ์ฐพ๋ ํค์ ๊ฐ์ ๋ฐํํ๊ณ ์๋ค๋ฉด ๊ธฐ๋ณธ ๊ฐ์ ๋ฐํํ๋ ๋ฉ์๋
key - ๊ฐ์ ๊ฐ์ ธ์์ผ ํ๋ ์์์ ํค
defaultValue - ์ง์ ๋ ํค๋ก ๋งคํ๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ฐํ๋์ด์ผ ํ๋ ๊ธฐ๋ณธ๊ฐ
getOrDefault๋ฅผ ์ฌ์ฉํด์ c ๋ฌธ์์ด์ด ์์ผ๋ฉด ๊ทธ ๋ฌธ์์ด ์์น๋ฅผ ๋ฐํํ๊ณ i - 1 ๊ฐ์ answer์ ๋ฃ์ด์ฃผ์ง๋ง,
๋ง์ฝ ์๋ค๋ฉด i+1 ๊ฐ์ ๋ฐํํ๊ณ ๊ทธ ๊ฐ์ i์ ๋นผ์ค๋ค.