์ค๋ ์ฐ๋ฆฌ๋ ๊ณ์น๊ณผ ๊ณ์น์ ์ฐพ๋ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ ๋ํด ์ด์ผ๊ธฐํ ๊ฒ์
๋๋ค. ์ด๊ฒ์ ํ๋ก๊ทธ๋๋จธ๊ฐ ์๊ณ ์์
ํ ์ ์์ด์ผ ํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๊ธฐ๋ฅ ์ค ํ๋์
๋๋ค. ๊ธ์, ์์ํ์. n!์ผ๋ก ํ์๋๋ ์ซ์ n์ ๊ณ์น์ 1์์ n๊น์ง์ ๋ชจ๋ ์์ฐ์์ ๊ณฑ(๊ณฑ์
) ๊ฐ์
๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ํ์๋ฉ๋๋ค(์ํ ์ง์์ ์๋กญ๊ฒ ํฉ์๋ค).
1! = 1 2! = 1 * 2 = 2 3! = 1 * 2 * 3 = 6 4! = 1 * 2 * 3 * 4 = 24 5! = 1 * 2 * 3 * 4 * 5 = 120
๊ทธ๋ฆฌ๊ณ 0์ ๋ํ ์์ ๊ท์น์ด ํ๋ ๋ ์์ต๋๋ค.
!0 = 1
6์ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๊ณ ์ถ๋ค๋ฉด! ๊ทธ๋ฆฌ๊ณ 4!:
6!-4! = 1โ
2โ
3โ
4โ
5โ
6 - 1โ
2โ
3โ
4 = 720 - 24 = 696
์ด๊ฒ์ด ํ๋ก๊ทธ๋๋ฐ์์ ๊ตฌํ๋ ๋ ์ด๋ป๊ฒ ๋ณด์ด๋์ง ๋ด
์๋ค. Java์์ ๊ณ์น ๊ณ์ฐ์ ์ํํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๊ณ์น ํ๋ก๊ทธ๋จ์ ์ผ๋ฐ ์๋ฃจ์
๋ค์์ ๋ฃจํ๋ฅผ ์ฌ์ฉํ๋ ๊ฐ๋จํ ๊ณ์น ํ๋ก๊ทธ๋จ์ ๋๋ค.
class FactorialExample{
public static void main(String args[]){
int i,fact=1;
int number=7;// our number to do the necessary calculations in class Factorial
for(i=1;i<=number;i++){
fact=fact*i;
}
System.out.println("Factorial of "+number+" is: "+fact);
}
}
์ฝ์์ ์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
7์ ๊ณ์น: 5040
๊ทธ๋ฆฌ๊ณ ์ ๋ฆฌ๋ฅผ ์ํ ๋ ํ๋์ ์:
public static int getFactorial(int f) {
int result = 1;
for (int i = 1; i <= f; i++) {
result = result * i; // finding factorial of number using loops
}
return result;
}
์ฌ๊ธฐ์ ์ด๋ ค์ด ๊ฒ์ ์์ต๋๋ค. ์ ๋ฌ๋ ์ซ์๋ฅผ ๋ฃจํ์ ํฌ๊ธฐ๋ก ์ฌ์ฉํ๊ณ f์ ๋๋ฌํ ๋๊น์ง ๋ชจ๋ ์ด์ ์ซ์๋ฅผ ๊ณฑํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฉ์ธ์์:
System.out.println(getFactorial(6) - getFactorial(4));
์ฝ๋๋ฅผ ํ
์คํธํ๋ฉด ์ํ๋ ๊ฒฐ๊ณผ์ธ 696์ ์ป๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
์ฌ๊ท ์๋ฃจ์
์ฌ๊ท๋ ๋ฉ์๋๊ฐ ์์ ์ ํธ์ถํ ๋ ๋ฐ์ํฉ๋๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ์ ์ฌ๊ท ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํฉ๋๋ค. ์์น์ ์ผ๋ก ๋ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.- ์ข ๋ฃ ์กฐ๊ฑด โ ์ข ๋ฃ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋๋ฉด ๋ฉ์๋๋ ์์ ์ ํธ์ถํ๋ ๊ฒ์ ์ค์งํ๊ณ ๊ฐ์ ์ ๋ฌํ๊ธฐ ์์ํด์ผ ํฉ๋๋ค. ๊ฒฐ๊ตญ ์ข ๋ฃ ์กฐ๊ฑด์ด ์์ผ๋ฉด StackOverflowError ๋ฅผ ์ป์ ๋๊น์ง ๋ฉ์๋๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์์ ์ ํธ์ถํ๋ ๋ฌดํ ๋ฃจํ๋ฅผ ๊ฐ๊ฒ ๋ฉ๋๋ค .
- ์ํฉ์ ํ์ํ ๋ ผ๋ฆฌ์ ์ฌ๊ท ํธ์ถ์ด ํ์ํ์ง๋ง ์ ๋ ฅ ๊ฐ์ด ๋ค๋ฆ ๋๋ค.
public static int getFactorial(int f) { // finding factorial of number using recursive solution
if (f <= 1) {
return 1;
}
else {
return f * getFactorial(f - 1);
}
}
์ฌ๊ท ์ข
๋ฃ ์กฐ๊ฑด์ 1์ ๋๋ฌํ ๋์
๋๋ค. ๋งค๊ฐ๋ณ์๊ฐ 1์ด ์๋๋ฉด ํ์ฌ ๊ฐ์ ๋ฉ์๋์ ๋ํ ๋ค์ ์ฌ๊ท ํธ์ถ์ ๊ฒฐ๊ณผ๋ฅผ ๊ณฑํฉ๋๋ค(ํ์ฌ ๊ฐ์์ 1์ ๋บ ๊ฐ์ ์ ๋ฌํจ).
์คํธ๋ฆผ ์๋ฃจ์
Java์ ์คํธ๋ฆผ ๊ธฐ๋ฅ์ ์ต์ํ์ง ์๊ฑฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋ก๊ณ ์นจํ๋ ค๋ ์ฌ๋์ ์ฌ๊ธฐ์์ ์ ๋ณด๋ฅผ ์ฝ์ผ๋ฉด ๋์์ด ๋ ๊ฒ์ ๋๋ค .
public static int getFactorial(int f) { // finding factorial of number using Stream
if (f <= 1) {
return 1;
}
else {
return IntStream.rangeClosed(2, f).reduce((x, y) -> x * y).getAsInt();
}
}
์ฌ๊ธฐ์๋ int ๊ฐ์ ์คํธ๋ฆผ์ผ๋ก ์์
ํ ๋ ์ถ๊ฐ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ํน์ IntStream ํด๋์ค๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด๋ฌํ ์คํธ๋ฆผ์ ์์ฑํ๊ธฐ ์ํด ์ ์ rangeClosed ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด ๋ฉ์๋๋ 2์์ f๊น์ง์ ๊ฐ์ 1์ฉ ์ฆ๋ถํ์ฌ ์์ฑํฉ๋๋ค. ๋ค์์ผ๋ก reduce ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ฐ์ ๊ฒฐํฉํฉ๋๋ค. ๋ณด๋ค ๊ตฌ์ฒด์ ์ผ๋ก, ๊ฐ์ ๊ฒฐํฉํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค. ๋ง์ง๋ง์ผ๋ก ํฐ๋ฏธ๋ getAsInt ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ฒฐ๊ณผ ๊ฐ์ ์ป์ต๋๋ค.
BigInteger ์ฌ์ฉ
Java์์ BigInteger ํด๋์ค๋ ์ซ์, ํนํ BIG ์ซ์๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค. ์ค์ ๋ก int ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ ์์ค ์์ด ์ฒ๋ฆฌํ ์ ์๋ ์ต๋ ๊ณ์น์ 31์ ๋๋ค. ๊ธด ๋ฐ์ดํฐ ์ ํ์ ๊ฒฝ์ฐ ์ต๋ ๊ณ์น์ 39์ ๋๋ค. ํ์ง๋ง ๊ณ์น 100์ด ํ์ํ๋ฉด ์ด๋ป๊ฒ ๋ ๊น์? ์ด์ ์๋ฃจ์ ์ BigInteger์ ์ ์ฉํด ๋ณด๊ฒ ์ต๋๋ค.์ผ๋ฐ ์๋ฃจ์
public static BigInteger getFactorial(int f) { // finding factorial of number using BigInteger
BigInteger result = BigInteger.ONE;
for (int i = 1; i <= f; i++)
result = result.multiply(BigInteger.valueOf(i));
return result;
}
์๊ณ ๋ฆฌ์ฆ์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋์ผํ์ง๋ง ์ฌ๊ธฐ์๋ BigInteger์ ๊ธฐ๋ฅ์ ์ฌ์ฉํฉ๋๋ค. BigInteger.ONE ์ ์์ ๊ฐ 1์ด๊ณ , multiply() ๋ ์ด์ ๊ณ์น ๊ฐ๊ณผ ํ์ฌ ์ซ์๋ฅผ ๊ณฑํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์ฌ๊ท ์๋ฃจ์
public static BigInteger getFactorial(int f) {
if (f <= 1) {
return BigInteger.valueOf(1);
}
else {
return BigInteger.valueOf(f).multiply(getFactorial(f - 1));
}
}
์๋ฃจ์
์ ์ผ๋ฐ์ ์ธ ๋
ผ๋ฆฌ๋ BigInteger ์์
์ ์ํด ์ผ๋ถ ๋ฉ์๋๊ฐ ์ถ๊ฐ๋์๋ค๋ ์ ์ ์ ์ธํ๋ฉด ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค.
์คํธ๋ฆผ ์๋ฃจ์
public static BigInteger getFactorial(int f) {
if (f < 2) {
return BigInteger.valueOf(1);
}
else {
return IntStream.rangeClosed(2, f).mapToObj(BigInteger::valueOf).reduce(BigInteger::multiply).get();
}
}
๋ชจ๋ ๊ฒ์ด ๋ณธ์ง์ ์ผ๋ก ๋์ผํ์ง๋ง BigInteger๋ฅผ ์ฌ์ฉํฉ๋๋ค. Stream ํด๋์ค๋ ์ฐ๋ฆฌ์๊ฒ mapToObj ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋๋ฐ, ์ฐ๋ฆฌ๋ ๊ณฑํ๊ธฐ ๋ฉ์๋ ๋ฅผ ์ฌ์ฉํ์ฌ int ๊ฐ์ BigInteger๋ก ๋ณํํ๊ธฐ ์ํด ์ฌ์ฉํฉ๋๋ค (๊ทธ๋ฆฌ๊ณ get()์ ์ ํ์ ๋ํผ ์์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ค๊ธฐ ์ํด ์ถ๊ฐ๋์์ต๋๋ค ). ์ธ์ 100์ผ๋ก ์ด ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ ์ค ํ๋๋ฅผ ์คํํ๋ฉด ์คํ ์ค๋ฒํ๋ก๋ฅผ ๋ฐฉ์งํ๊ณ ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651828625369792082722375825 1185210916864000000000000000000000000
GO TO FULL VERSION