
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/120822
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์์ด my_string์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. my_string์ ๊ฑฐ๊พธ๋ก ๋ค์ง์ ๋ฌธ์์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 1 ≤ my_string์ ๊ธธ์ด ≤ 1,000
์ ์ถ๋ ฅ ์my_stringreturn
| "jaron" | "noraj" |
| "bread" | "daerb" |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- my_string์ด "jaron"์ด๋ฏ๋ก ๊ฑฐ๊พธ๋ก ๋ค์ง์ "noraj"๋ฅผ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- my_string์ด "bread"์ด๋ฏ๋ก ๊ฑฐ๊พธ๋ก ๋ค์ง์ "daerb"๋ฅผ returnํฉ๋๋ค.
Approach 1 โ - ๋์ ์ด๊ธฐ ์ ๊ทผ๋ฒ
1. String์ธ my_string์ ๋ฐฐ์ด๋ก ๋ณํํ๋ค
2. ๋ค์ง์ด์ ๋ฐํํ answer์ ๋ฐฐ์ด์ ๋ง๋ ๋ค.
3. for๋ฌธ์ ํตํด ๋ฐฐ์ด my_string์ ์์์ธ ๋ฌธ์ ํ ๊ธ์๋ง๋ค answer ๋ฐฐ์ด์ ์์์ ๋ด๋๋ค.
์ด๋ answer[i] = my_string[my_string.length - i];๋ก ์์๋ฅผ ๋ค์ง๋๋ค.
class Solution {
public String solution(String my_string) {
String [] answer = new [my_string.length];
for (String s : my_string){
}
}
}
์ญ์๋..๊ฐ ๊ธธ์ด ๋จผ ๋์ ์ฝ๋...
Approach 2 โญ - ๋์ ์ ๊ทผ๋ฒ์ ๋ํ ๊ต์
์ฃผ์ ๋ฌธ์ ์
1. ๋ฌธ๋ฒ์ ์ค๋ฅ:
• new [my_string.length]๋ ๋ฐฐ์ด ์ ์ธ์ด ์๋ชป๋์๋ค. ์๋ฐ์์๋ ๋ฐฐ์ด ์์ฑ ์ ํฌ๊ธฐ์ ๋ฐ์ดํฐ ํ์ ์ ๋ช ์ํด์ผ ํ๋ค.
char[] answer = new char[my_string.length()];
• for (String s : my_string)๋ ์๋ชป๋ ๋ฐ๋ณต๋ฌธ์ด๋ค.
my_string์ ๋ฌธ์์ด์ด๊ณ , ๋ฌธ์์ด์ ๋ฐ๋ณตํ๋ ค๋ฉด char[] ๋๋ charAt()์ ์ฌ์ฉํด์ผ ํ๋ค.
2. ๋ฐ์ดํฐ ํ์ ์ ํ:
• String[] ํ์ ์ ์ฌ์ฉํ๋ ค ํ์ผ๋, ๋ฌธ์ ์์๋ ๋ฌธ์์ด์ ๋ค์ง์ด String ํ์ ์ผ๋ก ๋ฐํํด์ผ ํ๋ฏ๋ก ํ์ํ์ง ์๋ค.
• ๋์ char[]๋ StringBuilder๊ฐ ๋ ์ ํฉํ๋ค.
3. ๋ถํ์ํ ๋ณต์ก์ฑ:
• ๋ฐฐ์ด์ ์ด์ฉํด ์๋์ผ๋ก ๋ค์ง๋ ๋ฐฉ์์ ํจ์จ์ ์ผ ์ ์์ผ๋,
์๋ฐ์์ ๋ฌธ์์ด ์กฐ์์๋ StringBuilder์ reverse()๋ฅผ ํ์ฉํ๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ๋ ์๋ค.
Solution ๐ก
์๊ตฌ๋๋ ๋ ผ๋ฆฌ์ ํ์ด ๊ณผ์
1. ๋ฌธ์์ด ๋ณํ:
• ๋ฌธ์์ด์ ๋ฌธ์ ๋ฐฐ์ด(char[])๋ก ๋ณํํ์ฌ ๊ฐ๋ณ ๋ฌธ์์ ์ ๊ทผํ๋ค.
2. ๋ค์ง๊ธฐ ๋ก์ง ๊ตฌํ:
• ๋ฌธ์ ๋ฐฐ์ด์ ์ฌ์ฉํด ์ธ๋ฑ์ค๋ฅผ ๋ฐ์ (length - 1 - i)์ํค๋ฉฐ ๋ค์ง๋๋ค.
• ๋๋ StringBuilder์ reverse() ๋ฉ์๋๋ฅผ ์ด์ฉํด ๋ฌธ์์ด์ ๋ค์ง๋๋ค.
3. ๊ฒฐ๊ณผ ๋ฐํ:
• ๋ค์งํ ๋ฐฐ์ด ๋๋ ๋ฌธ์์ด์ ๋ค์ String์ผ๋ก ๋ณํํด ๋ฐํํ๋ค.
class Solution {
public String solution(String my_string) {
//1. ๋ฌธ์์ด์ ๋ฌธ์ ๋ฐฐ์ด๋ก ๋ณํ
char[] charArray = my_string.toCharArray();
//2. ๋ค์งํ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ฐฐ์ด ์์ฑ
char[] answer = new char[charArray.length];
//3. ๋ฌธ์ ๋ฐฐ์ด ๋ค์ง๊ธฐ
for (int i = 0; i < charArray.length; i++) {
answer[i] = charArray[charArray.length - 1 -i];
}
//4. ๊ฒฐ๊ณผ ๋ฐฐ์ด์ ๋ฌธ์์ด๋ก ๋ณํํด ๋ฐํ
return new String(answer);
}
}
StringBuilder๋ฅผ ์ฌ์ฉํ ๊ฐ๋จํ ๋ฐฉ๋ฒ
class Solution {
public String solution(String my_string) {
// StringBuilder๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด ๋ค์ง๊ธฐ
return new StringBuilder(my_string).reverse().toString();
}
}
๊ฐ ๋ฐฉ๋ฒ์ ํ๊ฐ
1. ๋ฐฐ์ด์ ์ฌ์ฉํ ๋ฐฉ๋ฒ
• ์ฅ์ :
• ๋ฌธ์์ด์ ์๋์ผ๋ก ๋ค์ง๋ ๊ณผ์ ์ ์ง์ ๊ตฌํํ์ฌ ์ดํด๋ฅผ ๋๋๋ค.
• ๊ณต๊ฐ ๋ณต์ก๋๊ฐ ๋ช ํํ๋ค.
• ๋จ์ :
• ์ฝ๋๊ฐ ๋ค์ ๋ณต์กํ๋ฉฐ, ์ง์ ์ ์ธ ๊ตฌํ์ผ๋ก ์ธํด ์ ์ง๋ณด์๊ฐ ์ด๋ ค์ธ ์ ์๋ค.
2. StringBuilder๋ฅผ ์ฌ์ฉํ ๋ฐฉ๋ฒ
• ์ฅ์ :
• ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋ ์ฑ์ด ์ข๋ค.
• ๋ฌธ์์ด ์กฐ์์ ์ต์ ํ๋ ์๋ฐ์ ๋ด์ฅ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ฏ๋ก ์ฝ๋ ํจ์จ์ฑ๊ณผ ์ ์ง๋ณด์๊ฐ ์ฉ์ดํ๋ค.
• ๋จ์ :
• ๋ฌธ์์ด ๋ค์ง๊ธฐ ๋ก์ง์ด ์จ๊ฒจ์ ธ ์์ด ํ์ต์ฉ์ผ๋ก๋ ๋ ์ง๊ด์ ์ด๋ค.
Reference ๐
1. char[] ๋ฐฐ์ด
char[] charArray = my_string.toCharArray();
• ์ค๋ช :
- toCharArray()๋ ๋ฌธ์์ด(String)์ ๋ฌธ์ ๋ฐฐ์ด(char[])๋ก ๋ณํํ๋ ๋ฉ์๋์ด๋ค.
- ์๋ฅผ ๋ค์ด, "hello"๋ผ๋ ๋ฌธ์์ด์ ['h', 'e', 'l', 'l', 'o']๋ก ๋ณํ๋๋ค.
- ๋ฌธ์ ๋ฐฐ์ด์ ๋ฌธ์์ด์ ๊ฐ ๊ธ์์ ๊ฐ๋ณ์ ์ผ๋ก ์ ๊ทผํ๊ฑฐ๋ ์กฐ์ํ ๋ ์ ์ฉํ๋ค.
์์ :
String str = "hello";
char[] charArray = str.toCharArray();
System.out.println(charArray[0]);
2. ๋ฌธ์์ด๋ก ๋ณํ (new String)
๋ฌธ๋ฒ:
return new String(anwer);
• ์ค๋ช :
- ๋ฌธ์ ๋ฐฐ์ด(char[])์ ๋ฌธ์์ด(String)๋ก ๋ณํํ๋ค.
- ์ ์ฝ๋์์๋ ๋ค์ง์ด์ง ๋ฌธ์ ๋ฐฐ์ด์ ๋ฌธ์์ด๋ก ๋ณํํด ๋ฐํํ๋ค.
์์ :
char[] charArray = {'h', 'e', 'l', 'l','o'};
String str = new String(charArray);
System.out.println(str); //"hello"
3. StringBuilder ํด๋์ค
return new StringBuilder(my_string).reverse().toString();
• ์ค๋ช :
- StringBuilder๋ ๋ฌธ์์ด์ ํจ์จ์ ์ผ๋ก ์กฐ์(์์ , ์ถ๊ฐ, ์ญ์ )ํ ์ ์๋ ํด๋์ค์ด๋ค.
- reverse(): ๋ฌธ์์ด์ ๋ค์ง๋ ๋ฉ์๋.
- toString(): StringBuilder ๊ฐ์ฒด๋ฅผ String์ผ๋ก ๋ณํํ๋ค.
StringBuilder sb = new StringBuilder("hello");
string reversed = sb.reverse().toString(); //"olleh"