The following recursive factorial method nFact() has a base case, but no general case. Complete the general case. public static int nFact(int n) { //n >=0 int factResult = 0; if (n == 0) { // base case factResult = 1; } else { // general case //TODO: add your code here. ____________________________________________ } return factResult; }//end of nFact()

Sure, here's the completed code with the general case implemented:

public static int nFact(int n) {
    int factResult = 0;
    if (n == 0) { // base case
        factResult = 1;
    } else { // general case
        factResult = n * nFact(n-1); // recursive call
    }
    return factResult;
}

In the general case, we calculate the factorial of `n` by multiplying `n` with the factorial of `n-1`, which is the result of a recursive call to `nFact(n-1)`. This process continues until `n` reaches the base case of 0, at which point the function returns 1.

相关问题

) Please write a recursive method that sums all the numbers in a given integer and returns the summation. Only recursive solutions will be marked. [12%] // Input : 178 // Output : 1*7*8 = 56 public static int multiplication(int number){ //Fill in the method body. }

Here's a recursive method in Java that sums all the digits of a given integer:

public static int sumDigits(int number) {
    if (number == 0) {
        return 0;
    } else {
        return (number % 10) + sumDigits(number / 10);
    }
}

Here's how it works:

1. The method takes an integer `number` as input.
2. If `number` is zero, the method returns zero (this is the base case).
3. Otherwise, the method returns the sum of the last digit of `number` (which is `number % 10`) and the result of calling itself recursively with the remaining digits (which is `sumDigits(number / 10)`).

For example, if we call `sumDigits(178)`, the method will compute `8 + sumDigits(17)`, which in turn will compute `7 + sumDigits(1)`, which finally returns `1`. So the overall result is `8 + 7 + 1 = 16`.

Note that this method doesn't use multiplication as in the example in the prompt. Instead, it sums the digits of the input number recursively.

Write a C++ Code For above Mr. Yu will share the details with you But it’s about Hanoi Tower

Hanoi Tower problem is a classic computer science puzzle that involves moving disks from one peg to another while following certain rules. The goal is to move all disks from the first peg to the third peg, obeying these constraints:

1. Only one disk can be moved at a time.
2. A larger disk cannot be placed on top of a smaller disk.

Here's a simple recursive algorithm in C++ for solving the Hanoi Tower problem:

#include <iostream>
using namespace std;

void hanoi(int n, char from_rod, char to_rod, char aux_rod) {
    if (n >= 1) {
        // Move n - 1 disks from 'from_rod' to 'aux_rod'
        hanoi(n - 1, from_rod, aux_rod, to_rod);
        
        // Move the nth disk from 'from_rod' to 'to_rod'
        cout << "Move disk " << n << " from rod " << from_rod << " to rod " << to_rod << endl;
        
        // Move the n - 1 disks from 'aux_rod' to 'to_rod', now including the nth disk
        hanoi(n - 1, aux_rod, to_rod, from_rod);
    }
}

int main() {
    int num_disks; // Number of disks
    cout << "Enter the number of disks: ";
    cin >> num_disks;

    // Call the function with initial parameters
    hanoi(num_disks, 'A', 'C', 'B'); // Assuming 'A', 'B', and 'C' are pegs

    return 0;
}

In this code, `hanoi` function takes three rods as arguments and recursively solves the tower by breaking down the problem into smaller sub-problems until it reaches the base case where there's no disk to move. When running this code, users can input the number of disks to start the tower, and the program prints out the steps needed to solve the puzzle.