-
์ํ ํ
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์ Math ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋๋ค. ์ด๊ฒ์ด ๋๋ถ๋ถ์ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๊ฒ ๋ ์๋ฃจ์ ์ ๋๋ค.
Math ํด๋์ค์๋ ์ผ๊ฐ๋ฒ, ๊ธฐํํ ๋ฐ ๊ธฐํ ์ํ ์ธก๋ฉด๊ณผ ๊ด๋ จ๋ ๋ฉ์๋๊ฐ ํฌํจ๋์ด ์์ต๋๋ค. ์ฌ๊ธฐ์ ๋ฉ์๋๋ ์ ์ ์ผ๋ก ๊ตฌํ๋๋ฏ๋ก ํด๋์ค ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ ๋ Math ํด๋์ค์ ์ด๋ฆ์ ํตํด ์ฆ์ ํธ์ถํ ์ ์์ต๋๋ค.
์ง์ํ๋ ์ด๋ป๊ฒ ์๊ฒผ๋์?
public static int pow(int value, int powValue) { return (int) Math.pow(value, powValue); }
Math ํด๋์ค์ ์ด ๋ฉ์๋๋ double ์ ํ์ ๊ฐ์ ๋ฐํํ๊ธฐ ๋๋ฌธ์ ์ ํ ์บ์คํธ(int)๋ฅผ ์ฌ์ฉํด์ผ ํ์ต๋๋ค(์ธ์๋ double์ด์ง๋ง ์์์ ์ ํ ์บ์คํธ๊ฐ ์ฌ์ฉ๋ฉ๋๋ค).
๊ทธ๋ฆฌ๊ณ ์ง๊ธ - ๋ณด๋์ค: ์ถ๊ฐ ์ต์ .
-
์ซ์์ ์ ๊ณฑ์ ๊ฐ
์๋ง๋ ๊ฐ์ฅ ๊ฐ๋จํ ๊ฒ๋ถํฐ ์์ํด ๋ณด๊ฒ ์ต๋๋ค.
์ ๊ณฑ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ด ์์ฑ๋ฉ๋๋ค.
public static int pow(int value){ return value*value; }
๊ธฐ๋ณธ์ผ๋ก ์ ํํ์ธ์:
public static void main(String[] args) { System.out.println(Solution.pow(7)); }
๊ทธ๊ฒ ์ ๋ถ์ ๋๋ค. ๋ณต์กํ๊ฑฐ๋ ๋ถํ์ํ ๊ฒ์ ์์ต๋๋ค.
-
ํ์ ๋ํ ์ซ์
๊ทธ๋ฌ๋ ์ ๊ณฑ์๊ฐ ์ฐ๋ฆฌ์๊ฒ ํ์ํ ์ ๋ถ๋ ์๋๋๋ค. ๋๋ถ๋ถ์ ์์ ์์๋ ์ด๋ ์ ๋ ์ซ์๊ฐ ํ์ํ๋ฏ๋ก ๋ค์์ ์ฝ๊ฐ ๋ ๋ณต์กํ ๋ฒ์ ์ด์ง๋ง ์ฌ์ฉ์ ์ ์ Java pow ๊ฐ์ ์ฌ์ฉํฉ๋๋ค.
public static void main(String[] args) { System.out.println(Solution.pow(7, 4)); } public static int pow(int value, int powValue) { int result = 1; for (int i = 1; i <= powValue; i++) { result = result * value; } return result; }
์๊ณ ๋ฆฌ์ฆ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ์์์ ๊ฒฐ๊ณผ๋ฅผ ์ค์ ํ ๋ค์ powValue๊ฐ ์๋ ๋ฃจํ๊ฐ ์คํ๋๋ ํ์(powValue ํ์)๋งํผ ๊ฐ์ ๊ณฑํฉ๋๋ค.
-
์ฌ๊ท
๋ค์ ๋ฐฉ๋ฒ์ ์ข ๋ ์ด๊ตญ์ ์ด์ง๋ง ๊ทธ๋ค์ง ๋ฉ์ง์ง๋ ์์ต๋๋ค.
์ฌ๊ท๋ ๋ฉ์๋๊ฐ ์์ ์ ํธ์ถํ ์ ์๋๋ก ํ๋ ๊ธฐ๋ฅ์ ๋๋ค. Java์๋ ์ด๋ฌํ ๋ฉ์ปค๋์ฆ์ด ์กด์ฌํ๋ฏ๋ก ์ด๋ฌํ ๋ฉ์๋๋ฅผ ์ฌ๊ท์ ์ด๋ผ๊ณ ํฉ๋๋ค.
์ ๋ถ๋ ์๋๋๋ผ๋ ๋ง์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ ์ ์์ต๋๋ค. ์ด๊ฒ๋ ์์ธ๋ ์๋๋ฏ๋ก ์ฌ๊ท์ ์ธ ๋ฐฉ์์ผ๋ก ์ซ์๋ฅผ ํน์ ๊ฑฐ๋ญ์ ๊ณฑ์ผ๋ก ๋์ด๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
public static int pow(int value, int powValue) { if (powValue == 1) { return value; } else { return value * pow(value, powValue - 1); } }
๋ณด์๋ค์ํผ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค.
- ์ฌ๊ท๋ฅผ ์ข ๋ฃํ๊ธฐ ์ํ ์กฐ๊ฑด, ์ฆ ํ์ ๊ฐ์ด 1์ ๋๋ฌํ๋ฉด ๋ค๋ก ๋ฌผ๋ฌ๋๊ธฐ ์์ํฉ๋๋ค.
- powValue - 1์ ์ฌ์ฉํ์ฌ ๋์ผํ ๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฒฐ๊ณผ์ value๋ฅผ ๊ณฑํ๋ ๋ฉ์ปค๋์ฆ ์์ฒด์ ๋๋ค.
์, ์ด์ ๊ฒ์ผ๋ฅธ ๋ฐฉ๋ฒ, ์ฆ "์ฆ์ ์ฌ์ฉ ๊ฐ๋ฅํ" ๋ฐฉ๋ฒ์ ์ดํด๋ณผ ์ฐจ๋ก์ ๋๋ค.
-
๋น ์ ์
BigInteger ํด๋์ค์ ์ฃผ์ ๋ชฉ์ ์ ์์ ํฌ๊ธฐ์ ์ ์๋ฅผ ์ ์ฅํ๋ ๊ฒ์ด์ง๋ง ๋์์ ์ด๋ฌํ ํฐ(๋๋ ๊ทธ๋ฆฌ ํฌ์ง ์์) ์ซ์๋ก ์์ ํ ์ ์๋ ๋ค์ํ ์ฐ์ ๋ฉ์๋๋ ์์ต๋๋ค.
์ด ๊ธฐ์ฌ ์์ BigInteger์ ๋ํ ์์ธํ ๋ด์ฉ์ ์ฝ์ ์ ์์ต๋๋ค .
๊ทธ๋ ๋ค๋ฉด Java์์ BigInteger๋ฅผ ์ฌ์ฉํ๋ฉด ์ง์ํ๋ ์ด๋ป๊ฒ ๋ ๊น์?
public static int pow(int value, int powValue) { BigInteger a = new BigInteger(String.valueOf(value)); return a.pow(powValue).intValue(); }
์์ฃผ ๊ฐ๋จํ๊ณ ๋ฌธ์ ๋ ์์ง ์๋์?
ะญะปะปะตะพะฝะพัะฐ ะะตััะธ
๋ ๋ฒจ 41
Java์์ ์ง์ํํ๋ ๋ฐฉ๋ฒ
์๋
ํ์ธ์! ์ธํฐ๋ท ๊ฒ์์ ํ๊ฑฐ๋ ํฌ๋ผ์ ๋์์ ์์ฒญํ๋ ๊ฒ์ ์๋ จ๋ ํ๋ก๊ทธ๋๋จธ์๊ฒ๋ ํํ ์ผ์
๋๋ค. ํ์ง๋ง ๊ฐ๋ฐ์๋ ๋๋ฌด๋ ๊ธฐ๋ณธ์ ์ด๊ณ ๋จ์ํด์ ์ด์ฌ์๋ผ๋ ์์์ผ ํ ์ฃผ์ ๋ค์ด ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ์ ๊ทธ ์ฃผ์ ์ค ํ๋๊ฐ ์์ต๋๋ค. ์ค๋์ Java์์ ์ง์ ์ฐ์ฐ์ด ์ํ๋๋ ๋ฐฉ๋ฒ์ ๋ํด ์ด์ผ๊ธฐํ๊ฒ ์ต๋๋ค. ๋น์ ์๊ฒ ์๋ฌด๊ฐ ์ฃผ์ด์ก๋ค๊ณ ์ ์ ์์ํด ๋ด
์๋ค. ์ด๋ ์ ๋ ์ซ์๋ฅผ ์ฐพ๋ ๊ฒ์
๋๋ค. ๋งค์ฐ ๊ฐ๋จํด ๋ณด์ด์ง๋ง ์๋ฃจ์
์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น? ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ๊ณผ ๋ช ๊ฐ์ง ๋์์ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ํด๊ฒฐ์ฑ
์ ๋ํด "๊น์ด ์ดํด๋ณด๊ธฐ" ์ ์ ๋จผ์ ์ซ์๋ฅผ ๊ฑฐ๋ญ์ ๊ณฑํ๋ ๊ฒ์ด ๋ฌด์์ธ์ง ๊ธฐ์ตํด ๋ด
์๋ค. ๊ฑฐ๋ญ์ ๊ณฑํ๋ ๊ฒ์ ํ๋์ ์ซ์์ ์ฌ๋ฌ ๋ฒ ๊ณฑํด์ง๋ ๋์์
๋๋ค. ๊ณฑํด์ง๋ ์๋ฅผ ๋ฐ์, ๊ณฑํด์ง๋ ํ์๋ฅผ ์ง์๋ผ๊ณ ํฉ๋๋ค. ์, ์ด๋ฌํ ๋ฐ์ ์์ฒด ๊ณฑ์
์ ๊ฒฐ๊ณผ๋ฅผ ์ง์ํ๋ผ๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 8์ ๊ฒฝ์ฐ 2x2x2=8์ด๋ฏ๋ก 2์ 3์ ๊ณฑ์
๋๋ค. ์ซ์์ 2์น์ ์ธ์๋ฅผ 2๋ฐฐ๋ก ํ๋ค๋ ์๋ฏธ์ด๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์ด ๊ฑฐ๋ญ์ ๊ณฑ์ ์ ๊ณฑ์น์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, 4 ์ ๊ณฑ = 4x4 = 16์
๋๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋ก ๊ณ ์ณค์ผ๋ฉฐ ์ด์ Java์์ pow๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ, ์ฆ ์ง์ํ ๋ฐฉ๋ฒ์ผ๋ก ์ง์ ์ด๋ํฉ๋๋ค.
GO TO FULL VERSION