
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/120908
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋ฌธ์์ด str1, str2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. str1 ์์ str2๊ฐ ์๋ค๋ฉด 1์ ์๋ค๋ฉด 2๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 1 ≤ str1์ ๊ธธ์ด ≤ 100
- 1 ≤ str2์ ๊ธธ์ด ≤ 100
- ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์, ์๋ฌธ์, ์ซ์๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์str1str2result
| "ab6CDE443fgh22iJKlmn1o" | "6CD" | 1 |
| "ppprrrogrammers" | "pppp" | 2 |
| "AbcAbcA" | "AAA" | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- "ab6CDE443fgh22iJKlmn1o" str1์ str2๊ฐ ์กด์ฌํ๋ฏ๋ก 1์ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- "ppprrrogrammers" str1์ str2๊ฐ ์์ผ๋ฏ๋ก 2๋ฅผ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- "AbcAbcA" str1์ str2๊ฐ ์์ผ๋ฏ๋ก 2๋ฅผ returnํฉ๋๋ค
Approach 1 โ - ๋์ ์ด๊ธฐ ์ ๊ทผ๋ฒ
str1๊ณผ str2๊ฐ ์ผ์นํ๋์ง ํ์ธํ๊ธฐ ์ํด for๋ฌธ์ ์ฌ์ฉํด ๊ฐ ์์๊ฐ ์ผ์นํ๋์ง (charAt(i)์ด์ฉ) ํ์ธํด์ผ ํ๋๋ฐ i๋ฒ ๋์์ ์ผ์นํ ํ์๊ฐ ์์ด์ ๊ณ ๋ฏผ์ด๋ค.
Approach 2 โญ - ๋ ผ๋ฆฌ์ ํ์ด
1. ํฌํจ ์ฌ๋ถ ํ์ธ :
์๋ฐ์์ ๋ฌธ์์ด ๋ด์ ํน์ ๋ฌธ์์ด์ด ํฌํจ๋์ด ์๋์ง๋ฅผ ํ์ธํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ String ํด๋์ค์ contains๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์ด ๋ฉ์๋๋ boolean ๊ฐ์ ๋ฐํํ๋ค.
- str1.contains(str2)๋ str1์ด str2๋ฅผ ํฌํจํ๋ฉด true๋ฅผ ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค.
2. ๊ฒฐ๊ณผ ๋ฐํ :
๋ฌธ์ ์ ์๊ตฌ ์ฌํญ์ ํฌํจ ์ฌ๋ถ๋ฅผ 1 ๋๋ 2๋ฅผ ๋ฐํํ๋ ๊ฒ์ด๋ฏ๋ก, if๋ฌธ ๋๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์ฒ๋ฆฌํ๋ค.
Solution ๐ก
class Solution {
public int solution(String str1, String str2) {
// str1์ด str2๋ฅผ ํฌํจํ๊ณ ์๋ค๋ฉด 1, ์๋๋ฉด 2 ๋ฐํ
return str1.contains(str2) ? 1 : 2;
}
}
1. contains ๋ฉ์๋ :
str.contains(str2)๋ str2๊ฐ str1 ์์ ์กด์ฌํ๋์ง๋ฅผ ํ์ธํ๋ค.
๋ฌธ์์ด์ ๋น๊ตํ๋ ๋ฐ ์์ด ์ง์ for๋ฌธ์ ๋๋ฉด์ ๋น๊ตํ ํ์ ์์ด contains ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ๋จํ๊ณ ํจ์จ์ ์ด๋ค.
2. ์ผํญ ์ฐ์ฐ์ :
str1.contains(str2) ? 1: 2 ๋ contains์ ๊ฒฐ๊ณผ๊ฐ true์ผ ๋ 1, ๊ทธ๋ ์ง ์์ ๋ 2๋ฅผ ๋ฐํํ๋ค.
์ผํญ ์ฐ์ฐ์๋ if -else๋ฅผ ๊ฐ๋จํ ํํํ ๋ ์ ์ฉํ๋ค.
3. ๋ฌธ์ ์์ ์ ์ํ ์๊ตฌ์ฌํญ ๋ฐ์ :
1๊ณผ 2๋ฅผ ๋ฐํํ๋๋ก ํ์ผ๋ฏ๋ก if๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ์กฐ๊ฑด์ ๋ฐ๋ผ ๊ฐ์ ์ค์ ํ๋ค.
Reference ๐- ๋ง์ฝ contains() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๊ตฌํํ๋ค๋ฉด?(๋น์ถ์ฒ)
class Solutio {
public int solution(String str1, String str2) {
// str2๊ฐ str1์ ๋ถ๋ถ ๋ฌธ์์ด์ธ์ง ํ์ธ
return str2.indexOf(str2) != -1 ? 1: 2;
}
}
์ผํญ ์ฐ์ฐ์ ํด์
(์กฐ๊ฑด์) ? ๊ฐ1 : ๊ฐ2
- (์กฐ๊ฑด์) : ํ๊ฐํ ์กฐ๊ฑด. ๊ฒฐ๊ณผ๊ฐ true ๋๋ false๊ฐ ๋๋ค.
- ๊ฐ 1: true์ผ ๋ ๋ฐํ๋๋ ๊ฐ.
- ๊ฐ 2 : false์ผ ๋ ๋ฐํ๋๋ ๊ฐ.
return str1.indexOf(str2) != -1 ? 1 : 2;
- str1.indexOf(str2) != -1:
str1.indexOf(str2)๋ str2๊ฐ str1์ ํฌํจ๋์ด ์๋ค๋ฉด ๊ทธ ์์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๊ณ , ํฌํจ๋์ง ์์ผ๋ฉด -1์ ๋ฐํ.
!= -1๋ “์ธ๋ฑ์ค๊ฐ -1์ด ์๋๋ค”๋ผ๋ ์๋ฏธ์ด๋ฉฐ, ์ด๋ str2๊ฐ str1 ์์ ํฌํจ๋์ด ์๋ค๋ ๋ป.
- ์ผํญ ์ฐ์ฐ์ ์ ์ฒด:
1. str1.indexOf(str2)์ ๊ฒฐ๊ณผ๊ฐ -1์ด ์๋๋ฉด:
• str2๊ฐ str1์ ํฌํจ๋ ๊ฒฝ์ฐ → 1 ๋ฐํ.
2. str1.indexOf(str2)์ ๊ฒฐ๊ณผ๊ฐ -1์ด๋ฉด:
• str2๊ฐ str1์ ํฌํจ๋์ง ์์ ๊ฒฝ์ฐ → 2 ๋ฐํ.
์ผํญ ์ฐ์ฐ์๋ ๋ค์์ ์ฝ๋์ ๊ฐ๋ค.
if (str1.indexOf(str2) != -1) {
return 1; // ํฌํจ๋์ด ์๋ค๋ฉด 1 ๋ฐํ
} else {
return 2; // ํฌํจ๋์ด ์์ง ์๋ค๋ฉด 2 ๋ฐํ
}
indexOf ๋ฉ์๋์ ์๋ ๋ฐฉ์
indexOf๋ ์๋ฐ์ String ํด๋์ค์์ ์ ๊ณตํ๋ ๋ฉ์๋๋ก, ํน์ ๋ฌธ์์ด ๋๋ ๋ฌธ์(char)๊ฐ ์ฃผ์ด์ง ๋ฌธ์์ด ์์์ ์ด๋์ ์์นํ๋์ง ํ์ธํ ๋ ์ฌ์ฉ๋๋ค.
int index = str.indexOf(substring);
• str: ๊ฒ์ ๋์ ๋ฌธ์์ด.
• substring: ์ฐพ์ผ๋ ค๋ ๋ฌธ์์ด.
• ๋ฐํ๊ฐ:
• substring์ด str ์์ ์์ผ๋ฉด ์ฒซ ๋ฒ์งธ๋ก ๋ํ๋๋ ์์น์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ (0๋ถํฐ ์์).
• substring์ด str ์์ ์์ผ๋ฉด -1์ ๋ฐํ.