Faktor (e) von N Zahlen in for Schleife

Question

Ich arbeite an einem Problem von CodeChef, wo ich die Fakultät von n Zahlen berechnen muss.

Der Benutzer gibt eine Zahl ein, die festlegt, wie viele Eingaben eine faktorielle Berechnung ausführen soll, und gibt dann die zu berechnenden Zahlen ein.

Mein Problem ist mit der Multiplikation selbst. Zum Beispiel, wenn ich einen int == habe 5 dann wird das Ergebnis sein, 20 (nur n von den letzten faktorielles berechnen wird, nicht alle von ihnen)

Hier ist, wo das Problem weiterhin besteht:

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 
    } 
} 

Die äußere Schleife definiert, wie viele Berechnungen durchgeführt werden sollen.

Die innere Schleife berechnet die Faktoren durch Iteration durch jeden Index von _numberToProcess und multipliziert sie mit jeder Zahl, die kleiner als die Zahl ist, auf der berechnet werden soll.

Das Problem ist, dass die faktorielle Berechnung überschreibt selbst

zum Beispiel:

faktoriellen von 5 Ergebnis: 20 aber es sollte 120 (überschreibt es sich, bis sie den letzten Multiplizierer erreicht) sein

Also versuchte ich folgendes:

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

Dies ist offensichtlich der gleiche wie _numbersToProcess[x] = _numbersToProcess[x] * y;

Aber das gibt ein completley anderes Ergebnis:

Wenn wir wieder Eingang 5 dann diese in der Ausgabe von -1899959296 führen.

Ich weiß, ich kann einfach kopieren und einfügen von anderen Einreichungen, aber ich möchte wissen, warum meine Methode nicht in der richtigen Ausgabe führt. Hier

ist das Verfahren in seiner Gesamtheit:

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(); 

Problem ist mit Ihrer inneren for-Schleife. Hier sind Sie immer, überschreiben Ergebnis Array.

, d.h. für y = 5; innere for-Schleife wird für 5 mal ausgeführt.

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 

. 
. 
. 
. 
. 

so geht es für 12 Iteration als _numbertoprocess [5] verändert und stoppt, sobald es weniger als 0 d.h -1899959296 erreicht.

iteration 12: 
    _numbertoprocess[5] = -1899959296. 

d.h Sie numbertoprocess jedes Mal in Ihrem inneren for-Schleife ändern.

Sie können es überprüfen, indem

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

in Ihrem inneren for-Schleife hinzufügen.

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 Schleifenbedingung y < _numberToProcess[x];. Es Vergleichen zwischen y und _numberToProcess[x] Array-Wert

Ich denke, Sie sollten Schleifenbedingung zu y < x

sein Glück bearbeiten.

Answer 4

ich hier eine rekursive Funktion factorial mit diesem

 /* 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-out wird es vielleicht helfen ...

#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; 
}