Algorithm Factorial in c, python, java and flowchart

Factorial

Q) Write an algorithm and draw the flowchart to calculate the factorial of a number.

n! = n × (n-1) × (n-2) × … × 3 × 2 × 1

For instance:

• 5! = 5 × 4 × 3 × 2 × 1 = 120
• 4! = 4 × 3 × 2 × 1 = 24
• 1! = 1 (by convention, the factorial of 1 is defined to be 1)

In many mathematical and statistical procedures, including permutations, combinations, and probability distributions, factories are utilized. They are also used in fields including engineering, physics, and computer science.

Algorithm Factorial

• This is a flowchart to calculate the factorial of the given number.
• n-Accepted number
• fact-Factorial of number
• i – loop variable,

Algorithm Factorial Steps

step 1: Start
step 2: [Accepte a number] Read n
step 3: set i=1, fact-1
step 4: Repeat steps 5 and 6 until i <= n
step 5: [calcute factorial] set fact=fact*i
step 6: set i=i+1
step 7: [ display factorial ] Print fact
step 8: Stop

Factorial Flowchart

An illustration of how to calculate the factorial of a given positive integer using a flowchart:

• The flowchart starts right here.
• ‘n’ should be a positive integer: ‘n’, a positive number, must be entered when the user is requested.
• Placing ‘factorial’ at 1: ‘factorial’ is a variable with a starting value of 1. The result of the last factorial will be kept in this variable.
• Put ‘current’ at 1: ‘current’ is a variable with a starting value of 1. The current integer will be tracked by this variable when the multiplication procedure is performed.
• Do the following when “current” is less than or equal to “n”: The loop in question will keep running until “current” exceeds “n.”
• Factorial multiplied by current: The ‘factorial’ is multiplied by the current value of ‘current’ throughout each iteration of the loop.
• ‘current’ is increased by 1 to represent the change from one integer to the next after each iteration.
• End While: The loop terminates when “current” exceeds “n.”
• As a consequence, print the value of ‘factorial’: The factorial of the input integer “n” is the end value of “factorial.”
• The flowchart comes to an end here.

The flowchart shows a straightforward approach that uses a loop and a few variables to keep track of the progress to compute the factorial of a given positive integer.

Factorial Flowchart steps

Start
↓
Input a positive integer 'n'
↓
Set 'factorial' to 1
↓
Set 'current' to 1
↓
While 'current' is less than or equal to 'n', do the following:
|
|  Multiply 'factorial' by 'current'
|  ↓
|  'factorial' = 'factorial' × 'current'
|  ↓
|  Increment 'current' by 1
|  ↓
End While
|
Output the value of 'factorial' as the result
↓
End

100! ≈ 9.33262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000000

It’s a huge number with 24 trailing zeros, as you can see. Factorials increase exponentially, making it difficult to type down the complete result for bigger quantities. Although it is frequently used in a variety of academic and theoretical debates, the factorial of 100 is not a realistic number to compute and deal with in the majority of real-world situations.

Factorial in c

A simple C program to figure out the factorial of an input positive integer

#include <stdio.h>

// Function to calculate the factorial
unsigned long long factorial(int n) {
    if (n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1);
}

int main() {
    int num;
    printf("Enter a positive integer: ");
    scanf("%d", &num);

    if (num < 0) {
        printf("Error: Factorial is not defined for negative numbers.\n");
    } else {
        unsigned long long result = factorial(num);
        printf("Factorial of %d is %llu.\n", num, result);
    }

    return 0;
}

The printf function is used by the program to compute and print the factorial result for non-negative inputs. Since factorials grow quickly and can exceed the range of conventional integer types, handling high factorial values requires the usage of the unsigned long long data type.

Factorial in C++

An application in C++ that computes the factorial of a given positive integer

#include <iostream>

// Function to calculate the factorial
unsigned long long factorial(int n) {
    if (n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1);
}

int main() {
    int num;
    std::cout << "Enter a positive integer: ";
    std::cin >> num;

    if (num < 0) {
        std::cout << "Error: Factorial is not defined for negative numbers.\n";
    } else {
        unsigned long long result = factorial(num);
        std::cout << "Factorial of " << num << " is " << result << ".\n";
    }

    return 0;
}

The program computes the factorial result for non-negative inputs, prints it, and displays the result using the cout stream object. To handle big factorial numbers, utilize the unsigned long long data type.

Factorial in Python

The factorial of a given positive integer using a Python function

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

try:
    num = int(input("Enter a positive integer: "))
    if num < 0:
        print("Error: Factorial is not defined for negative numbers.")
    else:
        result = factorial(num)
        print(f"Factorial of {num} is {result}.")
except ValueError:
    print("Error: Invalid input. Please enter a valid positive integer.")

If the input is negative, the software verifies it and shows an error message. The program computes the factorial result for non-negative inputs, prints it, and displays the result using the print() method.

Factorial in Java

A Java application that figures out the factorial of an input positive integer

import java.util.Scanner;

public class FactorialProgram {
    // Function to calculate the factorial
    public static long factorial(int n) {
        if (n == 0 || n == 1)
            return 1;
        else
            return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a positive integer: ");
        int num = input.nextInt();

        if (num < 0) {
            System.out.println("Error: Factorial is not defined for negative numbers.");
        } else {
            long result = factorial(num);
            System.out.println("Factorial of " + num + " is " + result + ".");
        }

        input.close();
    }
}

The application computes the factorial result for non-negative inputs and prints it using the System.out.println() function. Large factorial numbers are handled via the long data type.