๋ชจ์ค๋ถํธ 1 (with.Java)
โ๋ชจ์ค๋ถํธ 1โ ๋ฌธ์ ์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
๋จธ์ฑ์ด๋ ์น๊ตฌ์๊ฒ ๋ชจ์ค๋ถํธ๋ฅผ ์ด์ฉํ ํธ์ง๋ฅผ ๋ฐ์์ต๋๋ค.
๊ทธ๋ฅ์ ์ฝ์ ์ ์์ด ์ด๋ฅผ ํด๋ ํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค.
๋ฌธ์์ด letter๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, letter๋ฅผ ์์ด ์๋ฌธ์๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
๋ชจ์ค๋ถํธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
morse = {
'.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',
'--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',
'--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',
'...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',
'-.--':'y','--..':'z'
}
์ ํ์ฌํญ
- 1 โค letter์ ๊ธธ์ด โค 1,000
- return๊ฐ์ ์๋ฌธ์์ ๋๋ค.
- letter์ ๋ชจ์ค๋ถํธ๋ ๊ณต๋ฐฑ์ผ๋ก ๋๋์ด์ ธ ์์ต๋๋ค.
- letter์ ๊ณต๋ฐฑ์ ์ฐ์์ผ๋ก ๋ ๊ฐ ์ด์ ์กด์ฌํ์ง ์์ต๋๋ค.
- ํด๋ ํ ์ ์๋ ํธ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ํธ์ง์ ์์๊ณผ ๋์๋ ๊ณต๋ฐฑ์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์์
letter | result |
---|---|
โโฆ. . .-.. .-.. โโ | โhelloโ |
โ.โ. -.โ - โฆ. โ -.โ | โpythonโ |
๋ฌธ์ ์ ๋ํ ๋์ ํ์ด
class Solution {
public String solution(String letter) {
String[] morseArray = letter.split(" ");
StringBuilder answer = new StringBuilder();
String[] morseAlphabet = {
".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---",
"-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-",
"..-", "...-", ".--", "-..-", "-.--", "--.."
};
for (String morse : morseArray){
for (int i = 0; i < morseAlphabet.length; i++) {
if (morse.equals(morseAlphabet[i])) {
char decodedChar = (char) ('a' + i);
answer.append(decodedChar);
}
}
}
return answer.toString();
}
}
ํ์ด ์ค๋ช
split: ๋ฌธ์์ด์ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋์ด ๋ฐฐ์ด๋ก ๋ง๋ญ๋๋ค.
์ฌ๊ธฐ์๋ Morse ์ฝ๋๋ฅผ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋์ด ๋ฐฐ์ด๋ก ์ ์ฅํ๊ณ ์์ต๋๋ค.
(char) (โaโ + i): ASCII ์ฝ๋๋ฅผ ํ์ฉํ์ฌ i ๊ฐ์ ์ํ๋ฒณ์ผ๋ก ๋ณํํ๊ณ ์์ต๋๋ค. โaโ + i๋ i๊ฐ 0์ผ ๋ โaโ๋ฅผ ๋ฐํํ๊ณ , i๊ฐ 1์ผ ๋ โbโ๋ฅผ ๋ฐํํ๋ ์์ผ๋ก ๋์ํฉ๋๋ค.
์ (char) (โaโ + i)๋ฅผ ์ฌ์ฉํ๋๊ฐ i ๊ฐ์ ๋ฐ๋ผ โaโ์์๋ถํฐ ์ฐจ๋ก๋ก ์ํ๋ฒณ์ ์ป๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
(char)๋ ์ ์๋ฅผ ๋ฌธ์๋ก ๋ณํํ๋ ์บ์คํ ์ ์๋ฏธํ๋ฉฐ, โaโ + i๋ ASCII ์ฝ๋์์ i์ ํด๋นํ๋ ์ํ๋ฒณ์ ์ป๊ธฐ ์ํ ํํ์์ ๋๋ค.
์ด๋ฅผ ํตํด Morse ์ฝ๋๋ฅผ ์ํ๋ฒณ์ผ๋ก ๋ณํํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ StringBuilder๋ฅผ ์ฌ์ฉํ์ฌ ์ต์ข ๋ฌธ์์ด๋ก ๋ง๋ค๊ณ ์์ต๋๋ค.
Java์์๋ ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๊ฐ์ ๊ฐ์ ์ง์ ๋งคํํ๋ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ ์ฌ๋ฌ ๊ฐ์ง ์ด์ ๋ก ๋งคํ์ด ํ์ํ ๊ฒฝ์ฐ, HashMap ๋๋ ๋ค๋ฅธ ๋งคํ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํธ๋ฆฌํ ์ ์์ต๋๋ค.
HashMap์ ์ฌ์ฉํ ๊ฒฝ์ฐ
- ๋์ ์ธ ๋งคํ: ์๋ก์ด ์ํ๋ฒณ์ด๋ Morse ์ฝ๋๊ฐ ์ถ๊ฐ๋๊ฑฐ๋ ๋ณ๊ฒฝ๋ ์ ์๋ ๊ฒฝ์ฐ, HashMap์ ์ฌ์ฉํ๋ฉด ๋์ ์ผ๋ก ๋งคํ์ ์กฐ์ ํ ์ ์์ต๋๋ค.
- ํค-๊ฐ ์ ๊ด๋ฆฌ: HashMap์ ์ฌ์ฉํ๋ฉด ํค์ ๊ฐ์ ์์ ์ฝ๊ฒ ์ถ๊ฐ, ์ญ์ , ์์ ํ ์ ์์ต๋๋ค.
์์:
// ์ด๊ธฐํ ๋ธ๋ก์ ์ฌ์ฉํ์ฌ HashMap ์ด๊ธฐํ
static {
morseMap = new HashMap<>();
morseMap.put(".-", 'a');
morseMap.put("-...", 'b');
morseMap.put("-.-.", 'c');
...
}
๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
- ์ ์ ์ธ ๋งคํ: ๋งคํ์ด ๋ณ๊ฒฝ๋์ง ์๊ณ ๊ณ ์ ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ๊ฐ๋จํ ๊ตฌ์กฐ: ๋งคํ์ด ๊ฐ๋จํ๊ณ ๋ณ๊ฒฝ๋ ๊ฐ๋ฅ์ฑ์ด ๋ฎ์ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์ ์งํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ํฉ์ ๋ฐ๋ผ ์ ์ ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ๊ฐ๊ฐ์ ์ฅ๋จ์ ์ ๊ณ ๋ คํ์ฌ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ๋ฉ๋๋ค.