ก็ลองเขียน ขั้นตอน คร่าว ๆ ดูนะครับ
1 ขั้นของการ หา factor
ก็ ทำการ หาร ให้ลงตัว โดย ตั้ง ตัวที่จะหาร เป็น i
โดยเริ่มที่ i = 2 แล้วทำการ mod ให้ได้ผลเป็น 0
ถ้า ไม่เป็น 0 คือ หารไม่ลงตัว เพิ่ม i ไป ทีละหนึ่ง
สมมุติว่า หารลงตัว ก็เอา i ตัวเดิม หารอีก
แล้ว ทำการ บวก ค่า ที่หารลงตัวได้แต่ละครั้งนั้น ด้วย count
แล้ว เทียบค่า กับ max count ว่า count ที่เก็บได้
จากการ การหารลงตัว ของ i หนึ่งตัวนั้น มากที่สุด
เทียบกับ max count ของอันเดิม ได้หรือเปล่า
ถ้ามากกว่า ก็แทนค่า max count เข้าไปเป็นตัวใหม่
จนในที่สุด ก็ได้ max count ของ i ตัวที่มากที่สุด ก็เอา i ไปเป็น ตัวหาร
ของ power
2. เมื่อหาร power ด้วย max count ได้ ครั้งหนึ่ง สมมุติ ว่า max count คือ 5 ของ i ซึ่งเท่ากับ 2
4000/2 เท่ากับ 2000
ก็คำนวณ ผล ของ 2^4000 ด้วย f(2^2000) X f(2^2000)
ซึ่ง ใน f(x) นี้ ก็จะทำการ หา ตัวประกอบ ที่พบบ่อยที่สุด อีก เพื่อทำการ หาตัวหารใหม่
สมมุติ เป็น 2 อีกครั้ง
ใน f(2^2000) แต่ละตัว ก็จะคำนวณผล ที่กลับมาเป็น
f(2^1000) X f(2^1000)
แต่เมื่อไหร่ ที่ค่า i เปลี่ยนเป็น 5
เช่น f(2^1000) คำนวณ จาก 1000/5
ได้เป็น f(2^200)X f(2^200)x f(2^200) x f(2^200) x f(2^200) [คูณกัน i ครั้ง]
คือ หา ผลที่จะคำนวณ เป็นลำดับขั้น ไปจนถึง
จุดที่เป็น ฐาน ที่จะิเริ่ม คำนวณ กันจริง
ซึ่ง อาจตั้งไว้ว่า
ถ้า power น้อยกว่า 16 สมมุิติ
ก็จะเริ่ม ทำการ
3. คำนวณ หาค่า ของ 2^ (power ที่น้อยกว่า 16)
ก็ใช้ ฟังค์ชั่น power ที่มีอยู่ทั่วไป คูณ ให้ได้ ค่าออกมา
ได้เท่าไหร่ ก็ทำการ mod ด้วย
ให้ j = 0 แล้วเพิ่มขึ้นทีละหนึ่ง
แล้ว mod ด้วย 10 ยกกำลัง j
ผลลัพธ์ที่ได้ จากการ mod แต่ละครั้ง จะถูกใส่ใน linked list
คือ ค่า j คือ power ของ 10 และ ผลลัพธ์ที่ได้ จากการ mod คือ สัมประสิทธิ์
ก็จะได้ polynomial จากขั้นแรก return เป็น linked list ที่เก็บค่า มันไว้
พอ return ผลนี้ออก มา ก็เข้ามาในส่วนที่ จะทำ function
โดย มาในส่วน ของ power ที่ตั้งแต่ 16 ขึ้นไป
คือ การคูณกัน ของ polynomial
4. จะคูณกัน กี่ครั้ง ขึ้นกับ ตัว หาร i ที่นำมาคูณ
การคูณ polynomial
ก็ด้วย การดึง ข้อมูล ใน linked list ออกมา
ทีละตัว จาก linked list ตัวตั้ง
ดึงมาเป็น ตังตั้ง ตัวแรก แล้วเอา linked list อีกตัว (จากที่ return มาจาก function ตัวถัดไป)
ดึงออกมาที่ละตัว มาคูณกัน แล้วจับเอา ค่าสัมประสิทธิ ที่ได้จากการคูณสัมประสิทธิ์ กับค่า power ที่ได้จากการ บวกกันของ power
มาใส่ไว้ ใน list อันใหม่
แล้วคูณ ไปเรื่อย ๆ โดย ถ้า ผลคูณ ที่ได้ มีค่า power ใหม่ ก็เอามา find หาว่า power นั้นซ้ำหรือไม่
ถ้า power นั้น ซ้ำ ก็ดึง ค่าสัมประสิทธิ์เดิม ออกจาก list มาบวกค่า สัมประสิทธิ์ใหม่ เข้าไป
แล้วค่อยจับค่าสัมประสิทธิ์ใส่กลับ เข้าไปใน list
ทำแบบนี้ ไปเรื่อย ๆ จนได้ polynomial อันใหม่ ใน list อันใหม่
แต่ ต้องเอา list อันนั้น
มาตรวจ ค่าสัมประสิทธิ์ ว่าเกิน 9 หรือไม่ (ก็เทียบค่า ธรรมดา if( coefficient > 9) )
ถ้าเกิน ก็ทำการ mod 10 ผลลัพธ์ ใส่กลับไปเป็น ค่าสัมประสิทธิ์ ของ power ตัวนั้น
ส่วนที่เกิน เก็บค่าไว้ ใน temporary
แล้ว ดึง ค่าสัมประสิทธิ์ ของ power ตัวถัดไป ออกมาบวกกับ temporary นั้น
แล้วเทียบค่า ว่าเกิน 9 หรือไม่ ก็ทำแบบเดิม ไปเรื่อย ๆ
จนในที่สุด ก็ได้ power ตัวใหม่ ที่ใน list เดิม ยังไม่มี
สมมุติ list เดิม มี power ไปที่ 198 ก็อาจจะได้ power เพิ่มเป็น 199 และหรือ 200 เป็นต้น
ก็จะได้ ค่าสัมประสิทธิ์ที่ไม่เกิน 9 ทุกตัว
แล้วก็ return ผลออกมา คูณ กับ list ตัวถัดไป ที่รออยู่ จาก function ที่เหลือ
แล้ว ก็ return ผล ในรอบนั้น ออกมา เป็น list ตัวที่ใหญ่ขึ้น ใหญ่ขึ้น
แล้วก็ เอา list นั้น มาคูณกันในรอบใหม่ คูณกัน i ครั้งอีก (i ตัวนี้ อาจไม่เท่ากับ i ในรอบก่อน เพราะหา ตัวประกอบ คนละครั้งกัน)
จนในที่สุด ก็ ออกมาเป็น list ตัวสุดท้าย คือ
2^4000
ก็ดึงค่าสัมประสิทธิ์ ที่ได้ ทุกตัว มาเทียบ
กับตัวเลข 0 - 9 ว่าจัดอยู่ใน
0 กี่ตัว 1 กี่ตัว ...... ไปจนถึง 9
ก็ print ผล ออกมา