การหา Factorial ของ n (n!) 20000! ก็หาได้

สำหรับใครที่สงสัยว่า ถ้าจะหา Factorial ของ ตัวเลขเยอะๆ จะทำอย่างไร
เพราะ มัีนมี Limit ของ ค่าตัวแปร อยู่

เช่น 366! มีทั้งหมด 781 หลัก
แต่ว่า Double เก็บได้แค่ 1.1 x 10^308 เท่านั้นเอง

แล้วจะทำอย่างไรดีล่ะ?

อันนี้เป็นตัวอย่างของ 100! ครับ

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

เครื่องผมใช้เวลาคำนวณ 0.015 วินาที ครับ

ส่วน 366! ก็นี่เลยครับ

9188111095254496019212176412065202140090580418774645194675369840967804846588863095597762591294093025991679067056119532289819154031153412626361004655299317292397491794124983183190181485863175356339673174577270709354011349841159870162315388021077551574544150339454677263259292741490470278652918758618155319193382176540756099231912808304474174078456156193961001478398647954868692612278257154615836148475874973044173323055630082048837853679900542059105112845394071947192443208478530700194532818459855315620661704950466695965700997551748520475941227743698121112130799760005290512978278155471280205501581277410145813062661991385483143379923345195406432165518340351716868931650203126650444315203993600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

เครื่องผมใช้เวลา 0.031 วินาทีครับ

ส่วนตัวเลขอื่นๆ ก็ปรับแค่โค้ดด้านในโปรแกรม แค่ตัวเดียวครับ

ตัวเลขที่ผมลองมากสุดของผมก็คือ 20000! มากกว่านั้นขี้เกียจลองครับ
เฮ่อๆๆๆ

นี่ครับ โค้ด
[hide=2]
[code]
#include <stdio.h>
#include <time.h>
#define MAXARR 12900

long number[MAXARR];

int main(void) {

แล้วถ้าจะหาแฟคโดยใช้วิธีการแบบเรียกตัวเองล่ะครับ ต้องทำยังไงถึงจะให้โปรแกรมเรียกตัวเองได้
สรุปก็คือ เขียนโปรแกรมหาค่า Factorial โดยใช้วิธีการแบบเรียกตัวเอง อ่ะครับ

Quote:

---

แล้วถ้าจะหาแฟคโดยใช้วิธีการแบบเรียกตัวเองล่ะครับ ต้องทำยังไงถึงจะให้โปรแกรมเรียกตัวเองได้
สรุปก็คือ เขียนโปรแกรมหาค่า Factorial โดยใช้วิธีการแบบเรียกตัวเอง อ่ะครับ
[/b]

---

เขาเรียกว่า Recursion ครับ และนี่คือตัวอย่างในการหาค่า factorial แบบ recursion ครับ
[hide=2][code]#include <stdlib.h>
#include <iostream>
using namespace std;

unsigned long factorial (int n) {

ขอบคุณมากครับ แต่ดูแล้วงงไปเลย

ของผมเขียนได้อย่างงี้ครับ

**Hidden Content: To see this hidden content your post count must be 2 or greater.**

แต่มันได้แค่นิดเดียว ประมาณ 0-16

อยากให้มันได้เยอะๆอ่ะครับ ต้องใส่อะไรเพิ่มลงไปอีก

ถ้าเยอะกว่านั้นก็คงไม่ไหวล่ะครับทีนี้

เพราะว่า ค่าสูงสุดของตัวแปรหรือว่า Limit ของมันนั้น

เป็นได้เท่านั้นครับ

เพราะว่า Factorial นั้นจะเป็นเลขอะไรที่เพิ่มเร็ว มากกกๆๆๆๆๆๆๆๆๆๆๆ

ครั้ง ไม่ได้เพิ่มเป็น 2 หรือ 3 เท่า แต่เพิ่มทีละ หลายเท่ามาก (ขึ้นกับตัวเลขที่ใส่มา)

เพราะฉะนั้น หากจะหา N! จริงๆแล้วนั้น คงต้องใช้ Dynamic Programming อย่างเดียว (ล่ะมั้ง) ครับ


ปล. ถ้าใครมีวิธีดีๆ ก็ช่วยบอกต่อเป็นวิทยาทานกันด้วยนะค๊าาบ

Quote:

---

ถ้าเยอะกว่านั้นก็คงไม่ไหวล่ะครับทีนี้

เพราะว่า ค่าสูงสุดของตัวแปรหรือว่า Limit ของมันนั้น

เป็นได้เท่านั้นครับ

เพราะว่า Factorial นั้นจะเป็นเลขอะไรที่เพิ่มเร็ว มากกกๆๆๆๆๆๆๆๆๆๆๆ

ครั้ง ไม่ได้เพิ่มเป็น 2 หรือ 3 เท่า แต่เพิ่มทีละ หลายเท่ามาก (ขึ้นกับตัวเลขที่ใส่มา)

เพราะฉะนั้น หากจะหา N! จริงๆแล้วนั้น คงต้องใช้ Dynamic Programming อย่างเดียว (ล่ะมั้ง) ครับ[/b]

---

ผมจำไม่ได้แล้วว่าใครกล่าวเอาไว้ แต่ขอสรุปอะไรนิดนึงจากคำพูดประโยคนี้
recursive programming (แบบเรียกตัวเอง) กับ iterative programming (แบบวนลูป) สามารถเขียนทดแทนกันได้ครับ กล่าวคือ ถ้าเขียนเป็น recursive ได้ ก็จะเขียนเป็น iterative ได้เสมอ และถ้า เขียนเป็น iterative ได้ ก็ย่อมเขียนเป็น recursive ได้เช่นกัน เพราะฉะนั้น ถ้าท่านเขียน code มาเป็น iterative ได้แล้ว รับรองว่า สามารถเขียนเป็น recursive ที่ทำงานได้เหมือนกันได้อย่างแน่นอนครับ

Quote:

---

ถ้าเยอะกว่านั้นก็คงไม่ไหวล่ะครับทีนี้

เพราะว่า ค่าสูงสุดของตัวแปรหรือว่า Limit ของมันนั้น

เป็นได้เท่านั้นครับ

เพราะว่า Factorial นั้นจะเป็นเลขอะไรที่เพิ่มเร็ว มากกกๆๆๆๆๆๆๆๆๆๆๆ

ครั้ง ไม่ได้เพิ่มเป็น 2 หรือ 3 เท่า แต่เพิ่มทีละ หลายเท่ามาก (ขึ้นกับตัวเลขที่ใส่มา)

เพราะฉะนั้น หากจะหา N! จริงๆแล้วนั้น คงต้องใช้ Dynamic Programming อย่างเดียว (ล่ะมั้ง) ครับ
ปล. ถ้าใครมีวิธีดีๆ ก็ช่วยบอกต่อเป็นวิทยาทานกันด้วยนะค๊าาบ
[/b]

---

Quote:

---

ผมจำไม่ได้แล้วว่าใครกล่าวเอาไว้ แต่ขอสรุปอะไรนิดนึงจากคำพูดประโยคนี้
recursive programming (แบบเรียกตัวเอง) กับ iterative programming (แบบวนลูป) สามารถเขียนทดแทนกันได้ครับ กล่าวคือ ถ้าเขียนเป็น recursive ได้ ก็จะเขียนเป็น iterative ได้เสมอ และถ้า เขียนเป็น iterative ได้ ก็ย่อมเขียนเป็น recursive ได้เช่นกัน เพราะฉะนั้น ถ้าท่านเขียน code มาเป็น iterative ได้แล้ว รับรองว่า สามารถเขียนเป็น recursive ที่ทำงานได้เหมือนกันได้อย่างแน่นอนครับ
[/b]

---

ในแง่ของ output ที่ได้จะเหมือนกันครับ แต่ความเร็วในการทำงานจะต่่างกันในบางกรณี
อย่างในกรณีของ factorial นั้น ความเร็วที่ได้จะเท่ากัน แต่ถ้าเป็น fibonacci จะต่างกันมาก (ลองดูนะ)

วิธีที่ท่าน karun ใช้ ถือเป็นการใช้ dynamic programming แต่จุดเด่นอยู่ที่การนำ array มาเก็บผลลัพธ์
โดย array แต่ละตัวจะเก็บผลลัพธ์ตัวละ 5 หลัก (<100000) และตอนแสดงผลก็ค่อยนำ array มาแสดงผลต่อๆ กัน
จึงทำให้สามารถหาค่า factorial ที่มีค่าเยอะๆ ได้ครับ (ไอเดียดีครับ ^ ^)

จากโปรแกรมของท่าน Karum

ผมเอามาแปลงเป็นแบบใช้ฟังก์ชั่นได้แบบนี้ครับ

**Hidden Content: To see this hidden content your post count must be 2 or greater.**

ผมดูแล้ว และลองมาหลายวิธีแล้ว ทำยังไงก็ทำให้มันเป็นแบบ Recursion แล้วหาค่า n! ที่มีค่าเยอะๆ ไม่ได้ครับ
นั่งมันกับมันมาเป็นอาทิตย์ๆแล้วยังทำไม่ได้เลย

ท่านที่เก่งภาษา C ช่วยหาข้อสรุปให้ทีครับ ว่ามันสามารถทำเป็น Recursion ได้มั้ย (หาค่า n! n>20)

สำหรับโค้ดตัวนี้เป็น Recursion ครับ แต่หาค่าได้แค่ 13! ไม่เกินนั้น

**Hidden Content: To see this hidden content your post count must be 2 or greater.**

แล้วถ้าเขียนโปรแกรมแบบ Recursive โดยใช้ตัวแปรแบบอะเรย์ล่ะคับ ทำยังไงดี โปรแกรมผมเป็นแบบนี้คับ ถ้าจะทำเป็นแบบ Recursive ต้องทำยังไง

**Hidden Content: To see this hidden content your post count must be 2 or greater.**

ยังไง ไม่ค่อยเข้าใจอ่ะคับ

โค้ดแบบนี้ไม่เคยใช้ครับ ปกติจะใช้เป็นแบบ เรียกตัวเองมากกว่า แบบนี้ครับ :lol: อิงC++ครับ

**Hidden Content: To see this hidden content your post count must be 2 or greater.**