Python โปรแกรมหาแฟกทอเรียลของจำนวน

⚡ สรุปอย่างชาญฉลาด

แฟกทอเรียลของจำนวนใน Python คือผลคูณของจำนวนเต็มบวกทุกจำนวนจนถึงจำนวนนั้น Python คำนวณโดยใช้ลูป for, การตรวจสอบ if-else, การเรียกซ้ำ หรือฟังก์ชัน math.factorial() ที่มีอยู่แล้วในตัว

  • 🔘 สำหรับลูป: ทำซ้ำตั้งแต่ 1 ถึง n โดยคูณผลคูณที่ได้มาเรื่อยๆ เพื่อสร้างค่าแฟกทอเรียล
  • ☑️ การตรวจสอบเงื่อนไข If-else: ระวังการป้อนค่าลบ เพราะจะเกิดข้อผิดพลาด เนื่องจากค่าแฟกทอเรียลต้องการจำนวนเต็มที่ไม่เป็นลบ
  • การเรียกซ้ำ: ฟังก์ชันจะเรียกตัวเองซ้ำๆ โดยเพิ่มค่า n-1 ไปเรื่อยๆ จนกว่าจะถึงกรณีพื้นฐานที่เท่ากับ 0
  • 🧪 แฟกทอเรียลทางคณิตศาสตร์: นำเข้าสูตรคณิตศาสตร์และเรียกใช้ฟังก์ชันในตัวหนึ่งฟังก์ชันเพื่อให้ได้ผลลัพธ์ที่รวดเร็วและผ่านการทดสอบแล้ว
  • 🛠️ กรณีขอบ: แฟกทอเรียลของ 0 เท่ากับ 1 และ Python รองรับผลลัพธ์ขนาดใหญ่ได้อย่างเป็นธรรมชาติ
  • 🤖 ปัญญาประดิษฐ์และวิทยาศาสตร์ข้อมูล: ความน่าจะเป็น การจัดเรียง และไลบรารีต่างๆ เช่น SciPy ใช้แฟกทอเรียลกับอาร์เรย์

Python โปรแกรมหาแฟกทอเรียลของจำนวน

ส่วนด้านล่างนี้แสดงวิธีการคำนวณแฟกทอเรียลสี่วิธี Python — การใช้ลูป for, คำสั่ง if-else, การเรียกซ้ำ และ math.factorial() — รวมถึงอัลกอริธึมพื้นฐานและการประยุกต์ใช้งาน

แฟกทอเรียลของตัวเลขที่ใช้สำหรับการวนซ้ำ

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

ดังต่อไปนี้ Python โค้ดนี้แสดงวิธีการคำนวณแฟกทอเรียลโดยใช้ลูป

Python รหัส:

print ("Input a number")
factorialIP = int (input ())
ffactor23 = 1
for j in range (1, factorialIP+1):
   ffactor23 = ffactor23 * j
print ("The factorial of the number is “, ffactor23)

Output:

Input a number
4
The factorial of the number is 24

ดังกล่าวข้างต้น Python โปรแกรมนี้รับเฉพาะตัวเลขบวกเท่านั้น และไม่มีการตรวจสอบตัวเลขลบ ในโปรแกรมนี้ ตัวประกอบจะมีค่าเป็น 1 เมื่อ j เท่ากับ 1 เมื่อ j เท่ากับ 2 ตัวประกอบจะถูกคูณด้วย 2 และจะทำเช่นนี้ไปเรื่อยๆ จนกระทั่ง j เท่ากับ 4 จนได้ผลลัพธ์เป็น 24

แฟกทอเรียลของตัวเลขโดยใช้คำสั่ง IF…else

ดังต่อไปนี้ Python โค้ดนี้แสดงวิธีการใช้ฟังก์ชันแฟกทอเรียล ซึ่งแตกต่างจากเวอร์ชันที่ใช้ลูป โปรแกรมนี้จะตรวจสอบจำนวนลบก่อนคำนวณแฟกทอเรียลด้วย

ในก่อนหน้านี้ Python ในโค้ดนั้น ไม่ได้มีการตรวจสอบตัวเลขติดลบ ทำให้ฟังก์ชันแฟกทอเรียลไม่สมบูรณ์และมีแนวโน้มที่จะแสดงข้อความแสดงข้อผิดพลาดหากป้อนตัวเลขติดลบเข้าไป

ในโค้ดที่ให้มา ลูปเริ่มต้นด้วยเลขหนึ่งและคูณด้วยตัวเลขก่อนหน้าแต่ละตัว และฟังก์ชันยังตรวจสอบความถูกต้องของข้อมูลที่ป้อนเข้ามาสำหรับตัวเลขติดลบด้วย

Python รหัส:

print("Enter a number for the purpose of determining factorial")
factorialIP = int(input())
def factorial(factorialIP):
   if factorialIP < 0:
     print ('Factorial does not exist')
     factor=0
     return factor
   elif factorialIP == 0:
     factor=1
     return factor
     print(factor)
   else:
     factor = 1
     for j in range (1, factorialIP+1):
       factor = factor * j
     return factor
  print ("The factorial of the number is ", factorial(factorialIP))

Output:

1) Enter a number to determine factorial
   -4
   Factorial does not exist
   The factorial of the number is 0

2) Enter a number to determine factorial
   4
   Factorial does not exist
   The factorial of the number is 24

แจกันดอกไม้โรแมนติกนี้ Python โปรแกรมรับค่าตัวเลขบวก และเพิ่มการตรวจสอบค่าตัวเลขลบโดยใช้คำสั่ง if และ else ซึ่งจะคืนค่า 24 อย่างถูกต้องสำหรับค่าป้อนเข้า 4

แฟกทอเรียลของตัวเลขโดยใช้การเรียกซ้ำ

ดังต่อไปนี้ Python โค้ดนี้แสดงวิธีการใช้ฟังก์ชันแฟกทอเรียลโดยการเรียกซ้ำ ในตัวอย่างนี้ ฟังก์ชันเรียกซ้ำที่รับจำนวนเต็มบวกเป็นอินพุตจะคำนวณหาค่าแฟกทอเรียล

Python รหัส:

print("Enter a number for the purpose of determining factorial")
def factorial(num2):
  if num2 < 0:
    return 'Factorial does not exist'
  elif num2 == 0:
     return 1
  else:
     return num2 * factorial(num2-1)
number1 = int(input())
print("The factorial of the number is",factorial(number1))

Output:

Enter a number for the purpose of determining factorial
4
The factorial of the number is 24

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

ในข้างต้น Python ในโปรแกรมนี้ ฟังก์ชัน def factorial จะเรียกตัวเองซ้ำไปเรื่อยๆ จนกว่าตัวเลขจะถึงศูนย์ เมื่อตัวเลขถึงศูนย์แล้ว ฟังก์ชันจะกำหนดค่าเริ่มต้นให้ตัวเลขเป็น 1 และยุติการเรียกซ้ำ

แฟกทอเรียลของจำนวนโดยใช้ math.factorial()

ดังต่อไปนี้ Python โค้ดนี้แสดงตัวอย่างการคำนวณแฟกทอเรียลโดยใช้ math.factorial() ซึ่งสามารถใช้งานได้โดยการนำเข้าโมดูล math

ฟังก์ชันนี้ไม่รับค่าจำนวนเต็มลบ และจะแสดงข้อผิดพลาดหากป้อนค่าตัวเลขทศนิยม

Python รหัส:

print("Enter a number for computing factorial")
import math
number1 = int(input())
print("The factorial is as computed comes out to be ")
print(math.factorial(number1))

Output:

Enter a number for computing factorial
4
The factorial, as computed, comes out to be 24

อัลกอริทึมสำหรับโปรแกรมแฟกทอเรียลใน Python

ให้เรายกตัวอย่างที่แสดงให้เห็นแนวคิดของแฟกทอเรียล

ในการหาค่าแฟกทอเรียล 5 ให้ทำตามขั้นตอนต่อไปนี้:

5! = 5 x (5-1) x (5-2) x (5-3) x (5-4)
5! =120

นี่ 5! แสดงเป็น 120

แผนภาพต่อไปนี้ช่วยในการทำความเข้าใจอัลกอริทึมของการคำนวณแฟกทอเรียล และในกรณีนี้ มาดูตัวอย่างแฟกทอเรียล 4 กัน

อัลกอริทึมสำหรับโปรแกรมแฟกทอเรียล

อัลกอริทึมพร้อมตัวอย่างรูปภาพของแฟกทอเรียล 4!

การประยุกต์แฟกทอเรียลใน Python

แฟกทอเรียลของตัวเลขมีการนำไปประยุกต์ใช้มากมายในวิชาคณิตศาสตร์ นี่คือการใช้งานที่สำคัญของ Python:

  • Python ช่วยในการคำนวณ ตามด้วยการพิมพ์ค่าแฟกทอเรียลได้รวดเร็วและมีประสิทธิภาพมากกว่าภาษาโปรแกรมอื่นๆ ที่มีอยู่
  • การขอ Python โค้ดนั้นเข้าใจง่ายและสามารถทำซ้ำได้ในแพลตฟอร์มต่างๆ และแฟกทอเรียล Python สามารถนำโปรแกรมนี้ไปใช้ในงานสร้างแบบจำลองทางคณิตศาสตร์ได้หลายงาน

คำถามที่พบบ่อย

แฟกทอเรียลของจำนวนเต็มที่ไม่เป็นลบ n เขียนแทนด้วย n! คือผลคูณของจำนวนเต็มบวกทั้งหมดตั้งแต่ 1 ถึง n ตัวอย่างเช่น 5! เท่ากับ 5 × 4 × 3 × 2 × 1 = 120

ตามนิยามแล้ว แฟกทอเรียลของ 0 คือ 1 ทุกวิธี ไม่ว่าจะเป็นลูป การเรียกซ้ำ หรือ math.factorial() จะคืนค่า 1 สำหรับอินพุต 0 และกรณีพื้นฐานนี้ยังหยุดการเรียกซ้ำด้วย

ใช่. Python จำนวนเต็มมีความแม่นยำไม่จำกัด ดังนั้น math.factorial(100) จึงให้ผลลัพธ์ 158 หลักโดยไม่เกิดการโอเวอร์โฟลว์ มีเพียงหน่วยความจำและเวลาในการทำงานเท่านั้นที่เพิ่มขึ้นตามขนาดของข้อมูลป้อนเข้า

A สำหรับห่วง โดยทั่วไปแล้วมักจะนิยมใช้มากกว่า ทั้งสองวิธีใช้เวลา O(n) แต่ลูปใช้หน่วยความจำคงที่ ในขณะที่การเรียกซ้ำจะเพิ่มสแต็กการเรียกซึ่งอาจเกิดข้อผิดพลาดได้ Pythonขีดจำกัดการเรียกซ้ำของ

วิธีการมาตรฐานทุกวิธีต้องใช้การคูณ n−1 ครั้ง ดังนั้นความซับซ้อนของเวลาจึงเป็น O(n) ลูปแบบวนซ้ำใช้พื้นที่ O(1) ในขณะที่การเรียกซ้ำใช้พื้นที่ O(n) สำหรับสแต็กการเรียก

การเรียกซ้ำแบบลึกสามารถเกินขีดจำกัดได้ Pythonค่าเริ่มต้นจะจำกัดการเรียกใช้ประมาณ 1000 ครั้ง ควรใช้ลูป for แบบวนซ้ำหรือ math.factorial() สำหรับข้อมูลขนาดใหญ่ หรือเพิ่มขีดจำกัดด้วย sys.setrecursionlimit()

ใช่แล้ว แฟกทอเรียลปรากฏอยู่ในคณิตศาสตร์เชิงการจัดเรียงและการแจกแจงความน่าจะเป็น เช่น การแจกแจงปัวซงและการแจกแจงทวินาม ซึ่งเป็นพื้นฐานของแบบจำลองการเรียนรู้ของเครื่องหลายอย่าง นอกจากนี้ ไลบรารีด้านวิทยาศาสตร์ข้อมูลยังมีตัวช่วยสร้างแฟกทอเรียลแบบเวกเตอร์สำหรับอาร์เรย์อีกด้วย

ใช่แล้ว GitHub Copilot และผู้ช่วย AI ที่คล้ายกันจะสร้างเวอร์ชันลูป การเรียกซ้ำ และฟังก์ชัน math.factorial() จากข้อความแจ้งสั้นๆ โปรดตรวจสอบคำแนะนำสำหรับเงื่อนไขการป้องกันตัวเลขติดลบและกรณีฐาน 0! เสมอ

สรุปโพสต์นี้ด้วย: