๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/12932
์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ ๋ค์ด n์ด 12345์ด๋ฉด [5, 4, 3, 2, 1]์ ๋ฆฌํดํฉ๋๋ค.
์ ํ ์ฌํญ
- n์ 10,000,000,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
n | return |
12345 | [5, 4, 3, 2, 1] |
๋ด๊ฐ ์์ฑํ ์ฝ๋
์ฒ์์๋ ์ซ์๋ฅผ 10์ผ๋ก ๋๋ ์ ๋จ์ ๋๋จธ์ง๋ฅผ ๋ฐฐ์ด์ ์
๋ ฅํ๋ฉด ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค. ์ฌ๊ธฐ์ ๋ฐ์ํ ๋ฌธ์ ์ ์ด ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ํด์ฃผ์ด์ผ ํ๋๋ฐ ๊ทธ ๊ธธ์ด๋ฅผ ์ด๋ป๊ฒ ํด์ผ ํ๋.... ๊ฐ ๋ฌธ์ ์๋ค...... ๐๐ ๊ทธ๋์ while๋ฌธ์ ์ด์ฉํด์ ์ฐจ๋ก๋๋ก ํ๋์ฉ ์ง์ด๋ฃ์ผ๋ฉด ๋๊ฒ ๋ค ์๊ฐํ๊ณ ์ฝ๋๋ฅผ ์ง ํ ์คํํ๋๋ ๋ณด๋ ๋ฏ์ด ๋นจ๊ฐ ๊ธ์จ๋ก ์๋ฌ๊ฐ ๋ฌ๋ค๋ ์ฝ๋๊ฐ ๋์๋ค ใ
ใ
๊ณ์ ์ฝ๋๋ฅผ ์์ ํ๋ฉด์ ์ ๋ต์ ์๋ํ์ง๋ง ์๋ฌ๋ง ๋์์.. ๊ฒฐ๊ตญ์ ๊ตฌ๊ธ๋ง์ ํตํด ๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ํ์ธํ๋๋ฐ ๋๋์ ์ ํ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํผ ๊ฒ์ ๋ณด๊ณ ์ ์ฐธ๊ณ ํด์ ์ ๋ฆฌํด๋ฌ์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค. ๐คจ๐คจ๐คจ
์ ๋ต ์ฝ๋
class Solution {
public int[] solution(long n) {
String str = Long.toString(n); //long ํ์
์ n์ String ํ์
์ผ๋ก ๋ณ๊ฒฝ!!!
int[] answer = new int[str.length()]; //์ ๋ต์ ๋ฃ์ answer ๋ฐฐ์ด ์์ฑ!
for (int i = str.length() - 1; i >= 0; i--) { //๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฌธ์ ํด๊ฒฐ. i์ ๊ฐ์ ์ต๋๊ฐ์์ ๋ด๋ ค์ค๋ ๋ฐฉํฅ์ผ๋ก ์์ฑ!
answer[str.length() - i - 1] = str.charAt(i) - '0'; //answer์ ๊ฐ ์ธ๋ฑ์ค์ ASCII ์ฝ๋๋ก ๊ณ์ฐํ ๊ฐ์ ์
๋ ฅ!
}
return answer;
}
}
์ฝ๋ ์ค๋ช
์ฐ์ Long.toString(n); ์ ํตํด long ํ์
์ n์ String ํ์
์ผ๋ก ํ๋ณํ์ ํด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ ๋ต์ ์ถ๋ ฅํ๋ answer ๋ณ์์ ๋ฐฐ์ด์ ์ ์ธํด์ฃผ๊ณ , ๊ทธ ๊ธธ์ด๋ String str์ ๊ธธ์ด๋ก ์ค์ ํด์ฃผ์๋ค.
๊ทธ ํ์ ๋ฌธ์์ด์ ๊ธธ์ด๋งํผ ๋ฐ๋ณต๋ถ์ ์คํํ๋๋ฐ,
์ฌ๊ธฐ์ ๊ฐ์ฅ ์ค์ํ ํฌ์ธํธ๋ ์์๋ฅผ ๋ค์ง์ด์ ๋ฐ๋ณต์ ์คํ์ ํด์ค๋ค๋ ์ ์ด๋ค!!
int i = str.length() - 1
String ํ์
์ str ๊ธธ์ด์ -1๋งํผ ๋ณ์ i์ ๊ฐ์ผ๋ก ์
๋ ฅํด ์ค๋ค.
answer[str.length() - i - 1]
answer ๋ฐฐ์ด์๋ ์์ฐจ์ ์ผ๋ก ๊ฐ์ด ์
๋ ฅ๋ ์ ์๋๋ก str.length() - i - 1์ ํด์ค๋ค. ์ด๋ฅผ ํตํด ๋ฌธ์์ด์ ๋ค์ง์ด์ ๋ฐ๋ณตํ์ง๋ง answer ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ ์์ฐจ์ ์ผ๋ก 0, 1, 2, ... ์์๋ก ์ฆ๊ฐํ๊ฒ ๋๊ณ ๊ฐ์ด ์
๋ ฅ๋๋ค.
str.charAt(i) - '0'
charAt(i)๋ i๋ฒ์งธ ์ธ๋ฑ์ค์ ํด๋นํ๋ String ํ์
์ ๋ฌธ์์ด์ char ํ์
์ผ๋ก ํ ๊ธ์์ฉ ์ถ๋ ฅํ๋ ํจ์์ด๋ค.
์ ๋ต์ ์
๋ ฅํ๊ธฐ ์ํด์๋ ๋ฌธ์์ด์ด ์๋ intํ์ผ๋ก ์
๋ ฅํด์ผ ํ๋๋ฐ, charAt(i)๋ char ํ์
์ผ๋ก ์ถ๋ ฅ์ด ๋์ ์ ๋ต์ด ๋์ง ๋ชปํ๋ค. ์ฌ๊ธฐ์ char ํ์
์ int ํ์
์ผ๋ก ๋ณ๊ฒฝํ๋ฉด ASCII ์ฝ๋ ๊ฐ์ผ๋ก ๋ฐ๋๊ฒ ๋๋ค.
์๋ฅผ ๋ค์ด n์ ๊ฐ์ด "123"์ด๋ผ๊ณ ํ์ ๋, charAt(0)์ ๊ฐ์ '1'์ด ๋๋ค. '1'๋ก ์
๋ ฅํ๋ ๊ฒ์ด ์๋ int ํ์
์ 1๋ก ๋ฐฐ์ด์ ์
๋ ฅ๋์ด์ผ ํ๊ธฐ ๋๋ฌธ์ '1'์ int ํ์
์ผ๋ก ๋ณํํ๊ฒ ๋๋ฉด 49์ ๊ฐ์ ์ป๊ฒ ๋๋ค. ํ์ง๋ง ํ์ํ ๊ฐ์ 1์ด๊ธฐ ๋๋ฌธ์ 48์ ๋นผ์ค์ผ ํ๋๋ฐ '0'์ ASCII ์ฝ๋ ๊ฐ์ด 48์ด๊ธฐ ๋๋ฌธ์ - '0'์ ๋ค์ ๋ถ์ฌ์ ๋ฐ๋ณตํ๋ฉด ์ฐจ๋ก๋๋ก ์ํ๋ ๊ฐ์ ์ป์ ์ ์๊ฒ ๋๋ค.
์ ๋ต ์ฝ๋๋ฅผ ๋ณด๊ณ ์๊ฐํ๊ฒ ๋ ๋ค๋ฅธ ํ์ด
class Solution {
public long[] solution(long n) {
String str = Long.toString(n);
long[] answer = new long[str.length()];
for (int i = 0; i < str.length(); i++) {
answer[i] = n % (long) 10;
n = n / 10;
}
return answer;
}
}
์ฝ๋ ์ค๋ช
์ ๋ต ์ฝ๋๋ฅผ ์ฐธ๊ณ ํด์ ์ฐ์ Long.toString(n); ์ ํตํด long ํ์
์ n์ String ํ์
์ผ๋ก ํ๋ณํ์ ํด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ ๋ต์ ์ถ๋ ฅํ๋ answer ๋ณ์์ ๋ฐฐ์ด์ ์ ์ธํด ์ฃผ๊ณ , ๊ทธ ๊ธธ์ด๋ String str์ ๊ธธ์ด๋ก ์ค์ ํด ์ฃผ์๋ค. ์ฌ๊ธฐ์ ์ ๋ต ์ฝ๋์ ๋ค๋ฅธ ์ ์ ๋ฐฐ์ด ํ์
์ long ํ์
์ผ๋ก ๊ฐ์ ธ๊ฐ๋ค๋ ์ ์ด๋ค.
๊ทธ ํ์ ์ ๋ต ์ฝ๋์ ๋ฐ๋ณต๋ฌธ๊ณผ ๊ฐ์ด ๋ฌธ์์ด์ ๊ธธ์ด๊น์ง ๋ฐ๋ณต๋ฌธ์ ์คํํ๋๋ฐ,
์ฌ๊ธฐ์๋ ๋ณ์ i์ ๊ฐ์ 0์์ ์์ฐจ์ ์ผ๋ก ์ฆ๊ฐํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ค!
answer[i] = n % (long) 10;
long ํ์
์ธ n์ ๋๋๊ธฐ ์ํด ๊ฐ์ ํ์
์ ๋ง๋ค๊ธฐ ์ํด (long) 10์ผ๋ก ํ๋ณํํ.
๋ฐ๋ณต๋ฌธ์ด ์คํ๋๋ฉด์ answer ๋ฐฐ์ด์ ์์ฐจ์ ์ผ๋ก ๋๋จธ์ง ๊ฐ์ ์
๋ ฅ๋๋ค.
n = n / 10
์
๋ ฅ๋ ๋๋จธ์ง๋ฅผ ์ ๊ฑฐํ๊ธฐ ์ํด ๋ณ์ n์ n / 10์ ๋ชซ์ ๋ค์ ๋ฃ์ด์ค๋ค.
๋ชจ๋ ๋ฐ๋ณต๋ฌธ์ด ์คํ๋๊ณ ๋๋ฉด ๋ค์ง์ด์ง ๊ฐ์ด ๋ฐฐ์ด์ ์ฐจ๋ก๋๋ก ์
๋ ฅ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ ๋ต ์ฝ๋๊ฐ ๊ฐ๋
์ ์๊ณ ์๋ ์ฌ๋๋ค์๊ฒ๋ ๋ ์ฌ์ด ์ฝ๋์ด๊ณ ๋ฌธ์์ด์ ๋ํ ํจ์๋ฅผ ๋ชจ๋ฅด๋ ์ฌ๋๋ค์๊ฒ๋ ๋ด๊ฐ ์๊ฐํด ๋ธ ์ฝ๋๊ฐ ์ข ๋ ์ฝ๊ฒ ๋๊ปด์ง ๊ฒ ๊ฐ๋ค..!! ๐ค
'๐งฉ ํ๋ก๊ทธ๋๋จธ์ค > ๐ต ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์นํ๊ธฐ (0) | 2024.11.07 |
---|---|
์ ์ ์ ๊ณฑ๊ทผ ํ๋ณ (0) | 2024.11.06 |
๋ฌธ์์ด์ ์ ์๋ก ๋ฐ๊พธ๊ธฐ (1) | 2024.11.03 |
x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์ (0) | 2024.11.03 |
๋๋จธ์ง๊ฐ 1์ด ๋๋ ์ ์ฐพ๊ธฐ (2) | 2024.11.02 |