Factorial de un número sin usar la multiplicación

Dado un número positivo N , la tarea es calcular el factorial de N sin usar el operador de multiplicación.

Ejemplos:

Entrada : N = 5
Salida:
120
Explicación:
5*4*3*2*1=120

Entrada: N = 7
Salida:
5040

Observación:

A*B=A+A+A+A...B times.

This observation can be used as follows:
5!=5*4*3*2*1
=(5+5+5+5)*3*2*1
=(20+20+20)*2*1
=60+60
=120

Enfoque: El problema se puede resolver utilizando el concepto de bucles anidados . En lugar de usar el operador de multiplicación, la respuesta se puede calcular manualmente usando otro bucle. Siga los pasos a continuación para resolver el problema:

1. Inicializa una variable ans a N .
2. Iterar de N-1 a 1 , usando la variable i, y hacer lo siguiente:
   • Inicializar una suma variable a 0 .
   • Iterar de 0 a i-1, usando la variable j , y agregar ans a sum
   • Agregar suma a ans .
3. Imprimir respuesta _

A continuación se muestra la implementación del enfoque anterior.

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate factorial of the number
// without using multiplication operator
int factorialWithoutMul(int N)
{
    // variable to store the final factorial
    int ans = N;
 
    // Outer loop
    for (int i = N - 1; i > 0; i--) {
        int sum = 0;
 
        // Inner loop
        for (int j = 0; j < i; j++)
            sum += ans;
        ans = sum;
    }
    return ans;
}
 
// Driver code
int main()
{
    // Input
    int N = 5;
 
    // Function calling
    cout << factorialWithoutMul(N) << endl;
    return 0;
}

// Java program for the above approach
 
import java.io.*;
 
class GFG {
    // Function to calculate factorial of the number
    // without using multiplication operator
    public static int factorialWithoutMul(int N)
    {
        // variable to store the final factorial
        int ans = N;
 
        // Outer loop
        for (int i = N - 1; i > 0; i--) {
            int sum = 0;
 
            // Inner loop
            for (int j = 0; j < i; j++)
                sum += ans;
            ans = sum;
        }
        return ans;
    }
    // Driver code
    public static void main(String[] args)
    {
        int N = 5;
 
        // Function calling
        System.out.println(factorialWithoutMul(N));
        // This code is contributed by Potta Lokesh
    }
}

# Python3 program for the above approach
 
# Function to calculate factorial of the number
# without using multiplication operator
def factorialWithoutMul(N):
     
    # Variable to store the final factorial
    ans = N
 
    # Outer loop
    i = N - 1
     
    while (i > 0):
        sum = 0
 
        # Inner loop
        for j in range(i):
            sum += ans
             
        ans = sum
        i -= 1
         
    return ans
 
# Driver code
if __name__ == '__main__':
     
    # Input
    N = 5
 
    # Function calling
    print(factorialWithoutMul(N))
     
# This code is contributed by SURENDRA_GANGWAR

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to calculate factorial of the number
// without using multiplication operator
static int factorialWithoutMul(int N)
{
     
    // Variable to store the final factorial
    int ans = N;
 
    // Outer loop
    for(int i = N - 1; i > 0; i--)
    {
        int sum = 0;
 
        // Inner loop
        for(int j = 0; j < i; j++)
            sum += ans;
             
        ans = sum;
    }
    return ans;
}
 
// Driver code
public static void Main()
{
     
    // Input
    int N = 5;
 
    // Function calling
    Console.Write(factorialWithoutMul(N));
}
}
         
// This code is contributed by SURENDRA_GANGWAR

   <script>
// JavaScript program for the above approach
 
// Function to calculate factorial of the number
// without using multiplication operator
function factorialWithoutMul(N)
{
    // variable to store the final factorial
    let ans = N;
 
    // Outer loop
    for (let i = N - 1; i > 0; i--) {
        let sum = 0;
 
        // Inner loop
        for (let j = 0; j < i; j++)
            sum += ans;
        ans = sum;
    }
    return ans;
}
 
// Driver code
 
    // Input
    let N = 5;
 
    // Function calling
    document.write(factorialWithoutMul(N));
 
  // This code is contributed by Potta Lokesh
    </script>

120

Complejidad de Tiempo: O(N ² )
Espacio Auxiliar: O(1)