[ํ ์ฝํ ์ฝ1.5 4-03] ๋ฌธ์์ด ๋ฐ๊ธฐ
๐กํ ์ฝํ ์ฝ ์์ฆ 1.5 4ํ ๋ชจ์ off-site ๋ฌธ์ ํ์ด์ ๋๋ค. (2025.02.15)
๋ฌธ์
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค - ๋ฌธ์์ด ๋ฐ๊ธฐ
๋ด์ฉ
๋ฌธ์์ด "hello"์์ ๊ฐ ๋ฌธ์๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ์ฉ ๋ฐ๊ณ ๋ง์ง๋ง ๋ฌธ์๋ ๋งจ ์์ผ๋ก ์ด๋์ํค๋ฉด "ohell"์ด ๋ฉ๋๋ค. ์ด๊ฒ์ ๋ฌธ์์ด์ ๋ฏผ๋ค๊ณ ์ ์ํ๋ค๋ฉด ๋ฌธ์์ด A
์ B
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, A
๋ฅผ ๋ฐ์ด์ B
๊ฐ ๋ ์ ์๋ค๋ฉด ๋ฐ์ด์ผ ํ๋ ์ต์ ํ์๋ฅผ returnํ๊ณ ๋ฐ์ด์ B
๊ฐ ๋ ์ ์์ผ๋ฉด -1์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
๊ธฐ๋กํ๊ธฐ
๐ก ์ด๋๊น์ง ์๊ฐํด๋ดค๋์ง ๋จ๊ณ์ ์ผ๋ก ๊ธฐ๋กํด๋ด ๋๋ค.
ํ์ด
ํ์ด ์๊ฐ
์์ ์๊ฐ | ์ข ๋ฃ ์๊ฐ | ์ด ์์ ์๊ฐ |
---|---|---|
30๋ถ |
๋ฌธ์ ๋ถ์
์ ์ฝ ์ฌํญ ํ์ & ํ ์คํธ ์ผ์ด์ค ์์ฑ
์ ํ์ฌํญ
- 0 <
A
์ ๊ธธ์ด =B
์ ๊ธธ์ด < 100 A
,B
๋ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ ๋ ฅ๊ฐ ๋ถ์
๐ก ์ ๋ ฅ๊ฐ์ ๋ถ์ํ๋ฉด ๋ฌธ์ ์์ ์๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ ์ ์ผ๋ก ํ์ ํ ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
A | B | result |
---|---|---|
"hello" | "ohell" | 1 |
"apple" | "elppa" | -1 |
"atat" | "tata" | 1 |
"abc" | "abc" | 0 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- "hello"๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ๋ฐ๋ฉด "ohell"๊ฐ ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- "apple"์ ๋ช ๋ฒ์ ๋ฐ์ด๋ "elppa"๊ฐ ๋ ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์ #3
- "atat"๋ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ, ์ธ ์นธ์ ๋ฐ๋ฉด "tata"๊ฐ ๋๋ฏ๋ก ์ต์ ํ์์ธ 1์ ๋ฐํํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #4
- "abc"๋ ๋ฐ์ง ์์๋ "abc"์ด๋ฏ๋ก 0์ ๋ฐํํฉ๋๋ค.
์์ฌ ์ฝ๋ ์์ฑ
๐ก ์์ฌ ์ฝ๋๋ ๋์ ์ค์ฌ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ ๋ฌธ์ ํด๊ฒฐ ์์๋ก ์์ฑํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ฅผ ์ถฉ๋ถํ ํ ์คํธํด๋ด ๋๋ค.
solution(A, B) {
// while ๋ฌธ ์ฌ์ฉ
// A์ ํ์ ๋ ๋ฌธ์์ด ๋น๊ต
// - ๊ฐ์ ์ ํ์ ๋ฐํ
// B ํ์
// ํ์++
}
๊ตฌํ
1์ฐจ ํ์ด
import java.util.Arrays;
class Solution {
public int solution(String A, String B) {
int lenA = A.length();
char[] chars = B.toCharArray();
char[] rotate = new char[lenA];
int answer = 0;
while (answer < lenA) {
if (A.equals(String.valueOf(chars))) break;
for (int i = 0; i < lenA; i++) {
rotate[i] = chars[(i + 1) % lenA];
}
answer++;
chars = Arrays.copyOfRange(rotate, 0, lenA);
}
return lenA == answer ? -1 : answer;
}
}
Arrays.copyOfRange
์ฌ์ฉ์ด ์ฑ๋ฅ์ ์ผ๋ก ๋นํจ์จ์ ์ธ ๊ฒ ๊ฐ์ ๋ฆฌํฉํ ๋ง์ ์งํํ๋ค.
2์ฐจ ํ์ด
import java.util.ArrayDeque;
class Solution {
public int solution(String A, String B) {
int lenA = A.length();
StringBuilder sb = new StringBuilder(B);
for (int i = 0; i < lenA; i++) {
if (A.equals(sb.toString())) return i;
sb.insert(lenA, sb.charAt(0));
sb.delete(0, 1);
}
return -1;
}
}
sb.delete
๊ฐsb.insert
๋ณด๋ค ๋จผ์ ์์ฑ๋๊ธธ ๋ฐ๋์ง๋ง ๊ทธ๋ ๊ฒ ํ ๊ฒฝ์ฐsb.chartAt
์ฝ๋์์IndexOutOfRange
์์ธ๊ฐ ๋ฐ์ํ์ฌ ์ด๋ ๊ฒ ์์ฑํ์๋ค.
๋ณต๊ธฐํ๊ธฐ
๋ต์๊ณผ ๋์ ํ์ด๋ฅผ ๋น๊ตํด๋ณด์ธ์
class Solution {
public int solution(String A, String B) {
String tempB = B.repeat(3);
return tempB.indexOf(A);
}
}
- ํ์ด์ฌ์ ๊ฒฝ์ฐ ๋๋ ์ด๋ฐ ์์ผ๋ก ํ์๋๋ฐ ์๋ฐ๋ ์ด๋ ๊ฒ ํ๊ธฐ ์ซ์๋ค.