Fattoriale/i di N numeri per ciclo

Question

Sto lavorando su un problema da CodeChef in cui ho bisogno di calcolare il fattoriale di n numeri.

L'utente immette un numero che determina il numero di inti per eseguire un calcolo fattoriale e quindi immette i numeri da calcolare.

Il mio problema è con la moltiplicazione stessa. Per esempio se ho un int == 5, allora il risultato sarà 20 (si calcolerà n dall'ultimo fattoriale unico, non per tutti)

Qui è dove il problema esiste:

for(int x = 0; x < _numbersToProcess.Length; x++) {// Loop throuigh Array by index 
    for (int y = 1; y < _numbersToProcess[x]; y++) {// Y is equal to less than index x 
     _result[x] = _numbersToProcess[x] * y;// Multiply x by y then add to array 
    } 
} 

Il ciclo esterno definisce il numero di calcoli da eseguire.

Il ciclo interno calula i fattoriali iterando attraverso ogni indice di _numberToProcess e moltiplicandolo per ogni numero in meno rispetto al numero su cui calcolare.

Il problema è che il calcolo fattoriale stessa sovrascrive,

ad esempio:

fattoriale di 5 risultato: 20 ma dovrebbe essere 120 (essa si sovrascrive fino a raggiungere l'ultimo moltiplicatore)

Così ho provato quanto segue:

_result[x] = _numbersToProcess[x] *= y; 

Questo è ovviamente la stessa di _numbersToProcess[x] = _numbersToProcess[x] * y;

Ma questo dà un risultato diverso completley:

Se abbiamo di nuovo ingresso 5 allora questo comporterà l'uscita di -1.899,959296 millions.

So che posso facilmente copiare e incollare da altri invii ma voglio sapere perché il mio metodo non risulta nell'output corretto.

Ecco il metodo nella sua interezza:

int _numbers = int.Parse(Console.ReadLine());// Get number of ints to calculate 
     int[] _numbersToProcess = new int[_numbers];// Array of inputs 
     int[] _result = new int[_numbers]; 
     int i = 0; 

     while(i < _numbersToProcess.Length) { 
      _numbersToProcess[i] = int.Parse(Console.ReadLine()); 
      i++; 
     } 

     for(int x = 0; x < _numbersToProcess.Length; x++) {// Loop throuigh Array by index 
      for (int y = 1; y < _numbersToProcess[x]; y++) {// Y is equal to less than index x 
       _result[x] = _numbersToProcess[x] *= y;// Multiply x by y then add to array 
      } 
     } 

     for (int n = 0; n < _result.Length; n++) {// Y is equal to less than index x 
      Console.WriteLine(_result[n]);// Write to console 
     } 

     Console.ReadLine(); 

Answer 1

int _numbers = int.Parse(Console.ReadLine());// Get number of ints to calculate 
    int[] _numbersToProcess = new int[_numbers];// Array of inputs 
    int[] _result = new int[_numbers]; 
    int i = 0; 

    while(i < _numbersToProcess.Length) { 
     _numbersToProcess[i] = int.Parse(Console.ReadLine()); 
     i++; 
    } 

    for (int x = 0; x < _numbersToProcess.Length; x++) 
     {// Loop throuigh Array by index 
      int fact = 1; 
      for (int y = 1; y <= _numbersToProcess[x]; y++) 
      {// Y is equal to less than index x 
       fact = fact*y; 
      } 
      _result[x] = fact; 
     } 


    for (int n = 0; n < _result.Length; n++) {// Y is equal to less than index x 
     Console.WriteLine(_result[n]);// Write to console 
    } 

    Console.ReadLine(); 

Il problema è che con il vostro interno per ciclo. qui, sei sempre, prevalente array di risultati.

i.e per y = 5; interno per ciclo eseguito per 5 volte.

iteration -1 : 
    y=1, 
    _numbersToProcess[5]=5 
    _result[x]=5 

    iteration -2 : 
    y=2, 
    _numbersToProcess[5]=10 
    _result[x]=10 

iteration -3 : 
    y=3, 
    _numbersToProcess[5]=30 
    _result[x]=30 

. 
. 
. 
. 
. 

così vale per 12 iterazione come _numbertoprocess [5] sta cambiando e si arresta quando raggiunge inferiore a 0 cioè -1.899,959296 millions.

iteration 12: 
    _numbertoprocess[5] = -1899959296. 

cioè si cambia ogni volta numbertoprocess nel vostro interno per ciclo.

è possibile verificare con l'aggiunta di

Console.WriteLine(y); 
Console.WriteLine(_numbersToProcess[x]); 
Console.WriteLine(_result[x]); 

nel vostro interno per ciclo.

Answer 2

#include <stdio.h> 

int main() 
{ 
    int c, n, fact = 1; 

    printf("Enter a number to calculate it's factorial\n"); 
    scanf("%d", &n); 

    for (c = 1; c <= n; c++) 
    fact = fact * c; 

    printf("Factorial of %d = %d\n", n, fact); 

    return 0; 
} 

Answer 3

for (int y = 1; y < _numbersToProcess[x]; y++) {// Y is equal to less than index x 
    _result[x] = _numbersToProcess[x] *= y;// Multiply x by y then add to array 
} 

In condizione di loop y < _numberToProcess[x];. E confrontare tra y e _numberToProcess[x] valore di matrice

penso che si dovrebbe modificare condizione del ciclo di y < x

essere fortunati.

Answer 4

Qui sto usando una funzione ricorsiva fattoriale

 /* Factorial function*/ 
      int factorial (int n) 
      { 
      return (n*factorial(n-1)) 
      } 

      int _numbers = int.Parse(Console.ReadLine());// Get number of ints to calculate 
        int[] _numbersToProcess = new int[_numbers];// Array of inputs 
        int[] _result = new int[_numbers]; 
        int i = 0; 

        while(i < _numbersToProcess.Length) { 
         _numbersToProcess[i] = int.Parse(Console.ReadLine()); 
         i++; 
        } 

        for(int x = 0; x < _numbersToProcess.Length; x++) {// Loop throuigh Array by index 

          _result[x] = factorial(_result[x])// Multiply x by y then add to array 
         } 
        } 

        for (int n = 0; n < _result.Length; n++) {// Y is equal to less than index x 
         Console.WriteLine(_result[n]);// Write to console 
        } 

        Console.ReadLine(); 

Answer 5

check this out forse aiuterà ...

#include <stdio.h> 
#include <stdlib.h> 

long f(int n) { 
    if (n==0) return 1; 
    else return n * f(n-1); 
} 

int main(int argc, char *argv[]) { 
    long *factorials; 
    int *inputs; 
     int n; 

    printf("Enter number n = "); 
    scanf("%d", &n); 

    factorials = (long *) malloc(n*sizeof(long)); 
    inputs = (int *) malloc(n*sizeof(int)); 

    for (int i = 0; i < n; i++) { 
     long k; 
     printf("Enter %d number = ", i + 1); 
     scanf("%ld", &k); 
     inputs[i] = k; 
     factorials[i] = f(k); 
    } 

    for (int i = 0; i < n; i++) { 
     printf("Factorial for %d = %ld\n", inputs[i], factorials[i]); 
    } 

    return 0; 
}