๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ 10872๋ฒ ํฉํ ๋ฆฌ์ผ ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
๋ฌธ์
์์ ์ ๋ ฅ & ์ถ๋ ฅ
ํด๊ฒฐ๋ฒ
์ด ๋ฌธ์ ๋ ์ฌ๊ท ํธ์ถ์ ์์์๋ ๋ดค๋ฏ, ๊ฐ์ฅ ๊ธฐ์ด์ ์ธ ๋ฌธ์ ์ด๋ค.
ํน์ ๋ชจ๋ฅด๋ ๋ฌธ์ ์ ์กฐ๊ฑด์ ๋ํด์ ์ฃผ์ํด์ ๋ด๋ณด์.
์๊ฐ ๋ณต์ก๋
์๊ฐ ๋ณต์ก๋๋ n์ด ์ต๋ 12์ด๋ฉฐ ์ฌ๊ท๋ฅผ n๋ฒ ์ํํ๋๋ฐ, ์ฌ๊ธฐ์ ์ฌ๊ท๋ก ๋ค์ด๊ฐ์ ๋ ๋จ์ if ๊ฒ์ฆ๋ฌธ๊ณผ ๋ด๋ถ ์ฌ๊ท๋ฅผ ํธ์ถํ๋ ๋จ์ํ ๊ตฌ์กฐ ์ด๋ฏ๋ก o(n)
์ด๋ผ๋ ๋ณต์ก๋๊ฐ ๋์จ๋ค.
๊ทธ๋ผ o(12)
์ด๋ฏ๋ก 1์ด ๋ด์ ์ถฉ๋ถํ ์ํํ ์ ์์ ๊ฒ์ผ๋ก ๋ณด์ธ๋ค.
์ ๋ ฅ ์๋ฃํ
์
๋ ฅ์ 12 ๊น์ง์ด๋ฉฐ ์์ ์
๋ ฅ์ ๋ณด๋ฉด 10!
์ด 300๋ง์ด๋ผ๊ณ ํ๋ค. ๊ทธ๋ผ ๋์ถฉ 12!
์ 3์ต ~ 4์ต ์ฏค์ด ๋ ๊ฒ์ด๋ค.
int
์๋ฃํ์ ์ ์๋ฅผ ์ต๋ 21์ต์ ํํํ ์ ์๊ธฐ ๋๋ฌธ์ ์ถฉ๋ถํ 12!
์ ์ปค๋ฒํ ์ ์๋ค.
์ข ๋ฃ ์กฐ๊ฑด
์ฌ๊ทํจ์์์๋ ์ข ๋ฃ ์กฐ๊ฑด์ด ๋น ์ง๋ฉด ์ฑ๋ฅ ์ ํ๋ฅผ ์์ฃผ ์ง๊ฒฉ์ผ๋ก ๋ง๊ฒ๋๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์ข
๋ฃ ์กฐ๊ฑด์ด ํ์์ธ๋ฐ, ํฉํ ๋ฆฌ์ผ ํจ์์์ 1!์ 1์ด๋ฏ๋ก 1์ ๋ง๋๋ฉด ์ข
๋ฃํ๋ค๋ ์กฐ๊ฑด์ ์ถ๊ฐํด์ค ์ ์๋ค.
๊ผญ ์ฃผ์ํด์ผํ ์ค๋ต ํ๋ณด
์ฌ๊ธฐ ๋ฌธ์ ์์ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ์ ์๋ผ๊ณ ํ๋ค.
ํฌ๊ฑฐ๋ ๊ฐ์.
๊ทธ๋ผ 0์ด ๋ค์ด์ฌ ์ ์๋๋ฐ, ๋ง์ฝ 0์ด ๋ค์ด์จ๋ค๋ฉด ์ต์ด ํธ์ถ์ด ์๋ง factorial(0)
์ด ๋๋ค. ๊ทธ๋ผ ์ด๋ฅผ ๋ด๋ถ์ ์ผ๋ก ๋ณธ๋ค๋ฉด 0 * factorial(-1)
-1 * factorial(-2)
...์ ํธ์ถํ๊ฒ ๋๊ณ StackOverFlow๋ฅผ ๋ฐ์์ํฌ ์ ์๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์
๋ ฅ์ด 0์ผ ๋ ์ข
๋ฃ ์กฐ๊ฑด์ ํ๋ ๋ ์ถ๊ฐ์์ผ์ผ ํ๋ค.
์ ๋ต ์ฝ๋
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int n = Integer.parseInt(br.readLine());
bw.write(String.valueOf(factorial(n)));
bw.flush();
bw.close();
}
private static int factorial(int n) {
if(n == 0 || n == 1) return 1; // ์ข
๋ฃ ์กฐ๊ฑด
return n * factorial(n-1);
}
}
๋๊ธ