1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
KEY WORD
: Brute force
- key=String, value=Integer์ธ map์
๋ฌธ์๋ก ํํํ ์ซ์
=intํ ์ซ์
๋ก 1~9๊น์ง ๋ชจ๋ ์ซ์๋ฅผ ์ ์ฅํ๋ค. - ํฌ์ธํฐ๋ฅผ ํ๋ ์ฌ์ฉํ์ฌ ํด๋น ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์
word
๋ StringBuilder์ ์ ์ฅํ๋ค.
(1) word์ ๊ธธ์ด๊ฐ 3์ด์์ด๋ฉด map์ ํด๋น ๊ฐ์ key๋ก ๊ฐ์ง๋ ๊ฐ์ด ์๋ ๊ณ์ ํ์ธ
(2) ์์ผ๋ฉด ํด๋น ์๋ฅผ ์ซ์๋ก ๋ฐ๊พธ์ด ๋ต๋ณ์ด ๋๋ ans์ ์ ์ฅํ๊ณ word๋ฅผ ๋น์ด๋ค.
(3) ์์ผ๋ฉด ํฌ์ธํฐ๋ฅผ ํ ์นธ ์ด๋ํ์ฌ word๋ฅผ ๋ ์ฑ์ด๋ค.
(4) ๋ง์ฝ ์ซ์๋ผ๋ฉด ans์ ๊ฐ ์ ์ฅํ๊ณ ๋ฐ๋ก ๊ฑด๋ ๋ฐ๊ธฐ.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
static HashMap<String, Integer> map = new HashMap<>();
// 1. map์ ๊ฐ์ ์ ์ฅ
// 2. ํฌ ํฌ์ธํฐ ์ฌ์ฉ
// 2-1. right ์ฎ๊ฒจ์ left์์ ์ฐจ๊ฐ 3๊ธ์ ์ด์ ๋๋ฉด Map์ ๊ฐ์ด ์๋์ง ๊ณ์ ํ์ธ
// 2-2. ์์ผ๋ฉด ํด๋น ์๋ฅผ ์ซ์๋ก ์ฎ๊ธฐ๊ณ , left๋ฅผ right ์ชฝ์ผ๋ก ๋ก๊ฒจ์ 0์์ ์์
// 2-3. ์์ผ๋ฉด ํ ์นธ ๋๋ ค์ ๋ map ๋ค์ฌ๋ค๋ณด๊ณ ํ์ธ
// 2-5. ๋ง์ฝ ์ซ์๋ผ๋ฉด ๊ทธ๋ฅ ๊ฑด๋ ๋ฐ๊ธฐ
public int solution(String s) {
map.put("zero", 0); map.put("five", 5);
map.put("one", 1); map.put("six", 6);
map.put("two", 2); map.put("seven",7);
map.put("three",3); map.put("eight",8);
map.put("four", 4); map.put("nine", 9);
StringBuilder ans = new StringBuilder();
StringBuilder word = new StringBuilder();
int right= 0;
while(right < s.length()){
char now = s.charAt(right++);
if(now - 48 < 10){
ans.append(now);
continue;
}
word.append(now);
if(word.toString().length() >= 3){
int convert = map.getOrDefault(word.toString(), -1);
if(convert == -1) continue;
else{
ans.append(convert);
word.setLength(0);
}
}
}
return Integer.parseInt(ans.toString());
}
}
4. ์ฑ์ฅ ํ๊ธฐ
String.replaceAll("๋์๊ฐ", "๋ณ๊ฒฝ๊ฐ")
์ ์ด์ฉํด ํ ๋ฒ์ ๋ฐ๊พธ๋ ํ์ด๊ฐ ๋ ๊น๋ํ ๊ฒ ๊ฐ๋ค. String์ ๋ด์ฅ ๋งค์๋์ธ replaceAll(a,b)๋ String ๋ด๋ถ์ a๋ฅผ ๋ชจ๋ b๋ก ๋ณ๊ฒฝํด์ค๋ค. String.replace(A,B)
์์ ์ฐจ์ด์ ์ ๊ทธ๋ฅ replaceAll์ replace์ ๋ฌ๋ฆฌ ์ ๊ท ํํ์ ๋ํ ์์ ๋ฃ๋๋ค๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด๋ณด์.
String sample = "aaabbbcccabcddddabcdeee";
String result_1 = sample.replace("abc", "์");
String result_2 = sample.replaceAll("[abc]", "์");
System.out.println("replace๋ก ๋ณ๊ฒฝํ ๊ฐ: "+ result_1);
System.out.println("replaceAll๋ก ๋ณ๊ฒฝํ ๊ฐ: "+ result_2);
// *์ถ๋ ฅ
// replace๋ก ๋ณ๊ฒฝํ ๊ฐ: aaabbbcccc์dddd์deeee
// replaceAll๋ก ๋ณ๊ฒฝํ ๊ฐ: ์์์์์์์์์์์์์dddd์์์deeee
[ ]๋ผ๋ ์ ๊ท ํํ์์ or์ ๊ฐ๋ค. a์ด๊ฑฐ๋, b์ด๊ฑฐ๋, c์ด๋ฉด ์ ๋ถ "์"์ผ๋ก ๋ฐ๊พธ๋ผ๋ ์๋ฆฌ์ด๋ค.
5. ๋ค๋ฅธ ํ์ด
class Solution {
public int solution(String s) {
String[] strArr = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
for(int i = 0; i < strArr.length; i++) {
s = s.replaceAll(strArr[i], Integer.toString(i));
}
return Integer.parseInt(s);
}
}
0