Mit Rekursion eine Folge von Zahlen ohne lokale Variablen

Question

Diese Multiplikation war eine Frage auf einer Vergangenheit Prüfung, die Kommilitonen hatte und mich ratlos:

Verwenden Rekursion jede Zahl in einer Reihe zu multiplizieren zusammen ohne lokale Verwendung Variablen. Es sei angenommen:

• die Parameter positiv sind
• der erste Parameter kleiner als der zweite Parameter
• das Ergebnis kleiner als 2

Zum Beispiel rangeProduct(1, 5) sollte zurückkehren 120, weil 1x2x3x4x5 ist 120

U se diese Methode Unterschrift:

public static int rangeProduct(int valueOne, int valueTwo) { 
    return ?; 
} 

Wenn jemand weiß, wie dies zu tun, es ist einfach mein Lernen und profitieren, wenn Sie für einige der Praxis suchen oder einfach Empathie fühlen für eine hungernde, mäßig sachkundige Informatik-Dur, dann schwingen!

Answer 1

ich denke, das eine Lösung für Ihr Problem sein könnte:

public static int rangeProduct(int valueOne, int valueTwo) 
{ 
    if(valueOne <= valueTwo -1){ 
     valueOne++; 
     return (valueOne-1) * rangeProduct(valueOne, valueTwo); 
    } 
    return valueTwo; 
} 

Answer 2

Try this:

public static int rangeProduct(int valueOne, int valueTwo) { 
    if(valueOne>=valueTwo) 
    return valueOne; 
    return rangeProduct(valueOne, valueTwo-1) * valueTwo; 
} 

die Berechnung in der exakten Reihenfolge führt Sie angegeben:

1x2=2, 2x3=6, 6x4=24, 24x5=120 

Answer 3

public static int rangeProduct(int valueOne, int valueTwo) 
{ 
    // to avoid infinite loop if valueOne must be less or equal valueTwo 
    if (valueOne > valueTwo) { 
     throw new IllegalArgumentException(); 
    } 
    // terminal case : return one over two values 
    if (valueOne == valueTwo) { 
     return valueOne; 
    } 
    // recursive call with range's size decreasing 
    return valueOne * rangeProduct(valueOne+1, valueTwo); 
} 

Um die Anzahl der zu reduzieren rekursive Aufrufe der Größe kann eine der beiden Seiten verringert werden

public static int rangeProduct(int valueOne, int valueTwo) 
{ 
    if (valueOne > valueTwo) { 
     throw new IllegalArgumentException(); 
    } 
    if (valueOne == valueTwo) { 
     return valueOne; 
    } else if (valueOne == valueTwo-1) { 
     return valueOne*valueTwo; 
    } 
    return valueOne*valueTwo * rangeProduct(valueOne+1, valueTwo-1); 
} 

Answer 4

Das sollte nicht schwer überhaupt sein.

Lassen Sie uns dies iterativ zuerst tun, um zu verstehen, wie dies funktionieren sollte.

public static int rangeProduct(int valueOne, int valueTwo) 
    { 
     int prod = 1; 

     for(int i = valueOne; i <= valueTwo; i++) { 
      prod *= i; 
     } 

     return prod; 

    } 

So tun dies rekursiv nur so einfach wäre:

public static int rangeProduct(int valueOne, int valueTwo) 
    { 
     if (valueOne ==0 || valueTwo == 0) return 0; 

     //Range check 
     if (valueOne > valueTwo) return rangeProduct(valueTwo, valueOne); 

     if (valueOne < 0 && valueTwo > 0) return 0; //Because 0 is always in this range 

     if (valueOne == valueTwo) return valueTwo; 

     return valueTwo*rangeProd(valueOne, valueTwo-1); 
    } 

Logic für Rekursion verwendet: Sagen Sie bitte einen Bereich haben (3,5), dann:

(3,5) = 5 * (3,4) = 5 * 4 * (3,3) = 5 * 4 * 3 = 60
(-3, -1) = -1 * (- 3, -2) = -1 * -2 * (- 3, -3) = -6
(-3, 5) = 0 (weil dieser Bereich 0 enthält)
(5, 3) ist gleich wie (3,5), also kann auch 60 zurückgegeben werden.
(3, 3) -> jetzt, wenn beide Nein gleich sind, ist die Antwort im Grunde 3.

Hoffe, das hilft!

Answer 5

Hier ist ein 1-liner:

public static int rangeProduct(int valueOne, int valueTwo) { 
    return valueOne * (valueOne == valueTwo ? 1 : rangeProduct(++valueOne, valueTwo)); 
} 

Siehe live demo.