โค๏ธ Problem
- ๋ฌธ์
PROGRAMMERS-962 ํ์ฑ์ ๋ถ์์ฐฉํ ์ฐ์ฃผ๋นํ์ฌ ๋จธ์ฑ์ด๋ ์ธ๊ณํ์ฑ์ ์ธ์ด๋ฅผ ๊ณต๋ถํ๋ ค๊ณ ํฉ๋๋ค. ์ํ๋ฒณ์ด ๋ด๊ธด ๋ฐฐ์ด spell๊ณผ ์ธ๊ณ์ด ์ฌ์ dic์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. spell์ ๋ด๊ธด ์ํ๋ฒณ์ ํ๋ฒ์ฉ๋ง ๋ชจ๋ ์ฌ์ฉํ ๋จ์ด๊ฐ dic์ ์กด์ฌํ๋ค๋ฉด 1, ์กด์ฌํ์ง ์๋๋ค๋ฉด 2๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
- ์ ํ ์ฌํญ
- spell๊ณผ dic์ ์์๋ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ์์ต๋๋ค.
- 2 ≤ spell์ ํฌ๊ธฐ ≤ 10
- spell์ ์์์ ๊ธธ์ด๋ 1์ ๋๋ค.
- 1 ≤ dic์ ํฌ๊ธฐ ≤ 10
- 1 ≤ dic์ ์์์ ๊ธธ์ด ≤ 10
- spell์ ์์๋ฅผ ๋ชจ๋ ์ฌ์ฉํด ๋จ์ด๋ฅผ ๋ง๋ค์ด์ผ ํฉ๋๋ค.
- spell์ ์์๋ฅผ ๋ชจ๋ ์ฌ์ฉํด ๋ง๋ค ์ ์๋ ๋จ์ด๋ dic์ ๋ ๊ฐ ์ด์ ์กด์ฌํ์ง ์์ต๋๋ค.
- dic๊ณผ spell ๋ชจ๋ ์ค๋ณต๋ ์์๋ฅผ ๊ฐ์ง ์์ต๋๋ค.
- ์ ์ถ๋ ฅ ์ & ์ค๋ช
no | spell | dic | result |
1 | ["p", "o", "s"] | ["sod", "eocd", "qixm", "adio", "soo"] | 2 |
2 | ["z", "d", "x"] | ["def", "dww", "dzx", "loveaw"] | 1 |
3 | ["s", "o", "m", "d"] | ["moos", "dzx", "smm", "sunmmo", "som"] | 1 |
- "p", "o", "s" ๋ฅผ ์กฐํฉํด ๋ง๋ค ์ ์๋ ๋จ์ด๊ฐ dic์ ์กด์ฌํ์ง ์์ต๋๋ค. ๋ฐ๋ผ์ 2๋ฅผ returnํฉ๋๋ค.
- "z", "d", "x" ๋ฅผ ์กฐํฉํด ๋ง๋ค ์ ์๋ ๋จ์ด "dzx"๊ฐ dic์ ์กด์ฌํฉ๋๋ค. ๋ฐ๋ผ์ 1์ returnํฉ๋๋ค.
- "s", "o", "m", "d" ๋ฅผ ์กฐํฉํด ๋ง๋ค ์ ์๋ ๋จ์ด๊ฐ dic์ ์กด์ฌํ์ง ์์ต๋๋ค. ๋ฐ๋ผ์ 2์ returnํฉ๋๋ค.
[์ ์์ฌํญ] ์ ์ถ๋ ฅ ์ #3 ์์ "moos", "smm", "som"๋ "s", "o", "m", "d" ๋ฅผ ์กฐํฉํด ๋ง๋ค ์ ์์ง๋ง spell์ ์์๋ฅผ ๋ชจ๋ ์ฌ์ฉํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์ ๋ต์ด ์๋๋๋ค.
๐ Solution
ํ์ด
class Solution {
public int solution(String[] spell, String[] dic) {
int cnt = 0;
int answer = 0;
for (int i=0; i<dic.length; i++) {
if(dic[i].length() == spell.length) {
for (int j=0; j<dic[i].length(); j++) {
if(dic[i].contains(spell[j])) {
cnt++;
} else {
cnt = 0;
break;
}
}
if (cnt==spell.length) {
answer = 1;
break;
} else {
continue;
}
} else {
continue;
}
}
if(answer != 1) {
answer = 2;
} else {
;
}
return answer;
}
}
์ฒ๋ฆฌ์๋ VERY GOOD
๐ Comment
์ด ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ ๊ฝค ์ค๋ ์๊ฐ์ ํ๋นํ๋ค. ์ ์๋ 2์ ๋ฐ์ ์ ์ฌ๋์ง๋ง๐
์ฝ๋์ ํต์ฌ์ ๋ฐ๋ณต๋ฌธ์์์ break;๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด์๋ค.
๋๋ ๋จผ์ spell[]์ ๋ฐฐ์ด ์์๋ฅผ ํ ๋ฒ์ฉ๋ง ์ฌ์ฉํด์ผํ๋ค๋ฉด ์ผ๋จ spell.length๋ก dic[]์ ๋ฐฐ์ด ์์์ ๊ธธ์ด๋ฅผ ๋น๊ตํ์ฌ ์ผ์นํ๋ ๊ฒฝ์ฐ์๋ง ์กฐ๊ฑด๋ฌธ์ด ์คํ๋๋๋ก ํ์๋ค.
๊ทธ ๋ค์ ์ด์ค for๋ฌธ์ ์ฌ์ฉํ์ฌ dic[i] ์์ spell[j]๊ฐ ์๋์ง ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ์๋๋ฐ, spell[]์ ์์๋ฅผ ์ฌ์ฉํด์ ์กฐํฉํ๋ ๋จ์ด๋ ๋ฐ๋ณต๋ฌธ์ด ๋๋ ๋๊น์ง true๋ง์ด ๋์์ผ ํ๋ค.
cnt++;๋ฅผ ํตํด true๊ฐ์ด ๋์จ ํ์๋ฅผ ํฉ์ฐํ๊ณ , cnt์ spell.length๊ฐ ์ผ์นํ๋ฉด ๋ชจ๋ ์์๊ฐ ํ ๋ฒ์ฉ ์ฌ์ฉ๋์๋ค๋ ๋ป์ด๋ฏ๋ก answer์ 1์ ๋ฃ๋๋ก ํ์๋ค.
์ด ๋ฌธ์ ์์๋ spell์ ๋ด๊ธด ์ํ๋ฒณ์ ํ๋ฒ์ฉ๋ง ๋ชจ๋ ์ฌ์ฉํ ๋จ์ด๊ฐ dic์ ์กด์ฌํ๋์ง๋ฅผ ํ์ธํ๋ฉด ๋๋ฏ๋ก ํ๋ฒ์ด๋ผ๋ answer์ 1์ด ๋ด๊ธด๋ค๋ฉด ๋ฐ๋ก ๋ฐ๋ณต๋ฌธ์ ๋ฒ์ด๋๋๋ก ์์ฑํ๋ค.
if(dic[i].contains(spell[j])) {
cnt++;
} else {
cnt = 0;
break;
}
์ด ๋ถ๋ถ์์ else ์ ์ break;๋ฅผ ๋ฃ์ง ์์์ ๋๋ ํ ์คํธ ์ผ์ด์ค 8๋ฒ์์ ์คํจ๊ฐ ๋ด๋ค.
์ด else์ ์์๋ cnt์ ์ด๊ธฐํ๊ฐ ๋ฐ์ํ๋๋ฐ, spell[j]์ ์์๊ฐ dic[i]์ ์๋ ๊ฒฝ์ฐ์ ์ด๊ธฐํํ์ง ์์ผ๋ฉด cnt๊ฐ ๊ณ์ ๋์ ๋์๊ธฐ ๋๋ฌธ์ cnt๋ฅผ ์ด๊ธฐํํ๋ ์ฝ๋๋ฅผ ๋ฃ์๋ค. ๋๋ ์์ผํ๊ฒ๋ cnt๋ฅผ ์ด๊ธฐํํ๋ฉด spell[j]์ ์์๊ฐ dic[i]์ ์๋ ๊ฒฝ์ฐ๋ง์ ํ์ธํ ์ ์๋ค๊ณ ์๊ฐํ๋ค.
ํ์ง๋ง ๋ฐ์ ธ๋ณด๋ break;๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด spell[j]์ ์์๊ฐ dic[i]์ ์๋ ๊ฒฝ์ฐ์๋ j<dic[i].length();๊น์ง ๋ค์ ๋ฐ๋ณต๋ฌธ์ด ๋์๊ฐ๊ฒ ๋๋ค. ์ด ๋ cnt๊ฐ ์ด๊ธฐํ๋ ์ดํ์ ๋ฐ๋ณต๋ฌธ์ด ์ด์ด์ ์งํ๋๋ฏ๋ก ์ด ๋ ํ๋๋ผ๋ spell[j]์ ์์๊ฐ dic[i]์ ์๋ ๊ฒฝ์ฐ์๋ cnt++;๊ฐ ์คํ๋๊ฒ ๋๋ค. ๋ฐ๋ผ์ ์ํ๋ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง ์์๋ ๊ฒ์ ์ ์ ์๋ค.
๊ทธ๋์ spell[j]์ ์์๊ฐ dic[i]์ ์๋ ๊ฒฝ์ฐ๋ cnt์ ์ด๊ธฐํ์ break;๊ฐ ๋ฐ์ํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ์๋๋ ๋ชจ๋ ํ ์คํธ ์ผ์ด์ค๋ฅผ ํต๊ณผํ ์ ์์๋ค.
๋ฌธ์ ๋ฅผ ํ๊ณ ๋ ๋ค ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ํ์ธํ ์ ์๋๋ฐ, ๋ค๋ฅธ ์ฌ๋๋ค์ ์ฝ๋์ ๋ด ์ฝ๋๋ฅผ ๋น๊ตํด๋ณด๋ฉด ๊ฐ๋ ๋ฒ์ง ๋๊ฐ ์๋ค. ์ฃผ๋ก ๋ด ์ฝ๋๋ ์ค๊ธ์ฒ๋ผ ๋นผ๊ณกํ๋ฐ ๋ค๋ฅธ ์ฌ๋๋ค์ ์ฝ๋๋ ๊ฐ๊ฒฐ ๊ทธ ์์ฒด์ผ ๋์ด๋ค. ํนํ ๋๋ค์์ด๋ stream, builder์ ํ์ฉํด์ ์์ฑํ ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ด์ฉ์ง ์ฃผ๋ ๋ค๊ณ ๋ง๋ค.
'Programmers lv-0' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฑ์ ๋งค๊ธฐ๊ธฐ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.28 |
---|---|
ํน์ดํ ์ ๋ ฌ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (1) | 2022.11.28 |
์์ ์ง๋ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.28 |
์ง์ฌ๊ฐํ ๋์ด ๊ตฌํ๊ธฐ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (1) | 2022.11.28 |
์บ๋ฆญํฐ์ ์ขํ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (1) | 2022.11.28 |
์จ์ด์๋ ์ซ์์ ๋ง์ (2) - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.28 |
๋๊ธ