Function part 7 (Recursion 2)

Estimated reading: 4 minutes 379 views

Example 1:

#include <iostream>
using namespace std;
int sum(int n)
{
    if (n == 1)
        return 1;
    else
        return n + sum(n - 1);
}

int main()
{
    cout << sum(5) << endl;
    return 0;
}

This function calculates the sum of the first n natural numbers. The first n natural numbers are the numbers from 1 to n.

The function works by recursively calling itself to calculate the sum of the first n - 1 natural numbers. If the input number n is 1, the function simply returns the number 1, because the sum of the first natural number is 1. Otherwise, the function returns the sum of the input number n and the sum of the first n - 1 natural numbers.

Output:

Example 2:

#include <iostream>
using namespace std;
int sum(int x, int y)
{
    if (x == y)
        return x;
    else
        return y + sum(x, y - 1);
}

int main()
{
    cout << sum(4, 6) << endl;
    return 0;
}

This is a recursive function sum. It takes two integer parameters, x and y, which represent the range of numbers to sum. Here’s how the function works:

The base case: If x is equal to y, it means we have reached the end of the range, so it returns x. This is the terminating condition for the recursion.
The recursive case: If x is not equal to y, it adds the current value of y to the result of calling the sum function again with the same x and y-1. This effectively breaks down the sum of the range into smaller subproblems by reducing the upper bound (y) by 1 in each recursive call.

In the main function, it calls the sum function with the arguments 4 and 6 and then outputs the result to the console using cout. In this case, it will calculate the sum of integers from 4 to 6 (inclusive) and print the result.

When you run this code, it will output the sum of integers from 4 to 6, which is 4 + 5 + 6 = 15. So, the output of this code will be:

Example 3:

#include <iostream>

using namespace std;

void f(int n)
{
    if (n < 0)
        return;
    else
        for (size_t i = 0; i < n; i++)
        {
            cout << "*";
        }
    cout << endl;

    f(n - 1);
}

int main()
{

    f(5);

    return 0;

}

Here’s a step-by-step explanation of how the code works:

The f function takes an integer n as an argument.
It starts with a conditional statement:
If n is less than 0, it returns from the function immediately. This serves as the base case for the recursive function, ensuring that it eventually terminates.
If n is greater than or equal to 0, the function enters an else block, which contains a for loop.
Inside the for loop, there is a variable i of type size_t initialized to 0. The loop will run as long as i is less than n.
During each iteration of the loop, an asterisk (*) character is printed to the standard output using cout. This is done n times, so it will print a row of n asterisks.
After the loop, a newline character (endl) is printed to move to the next line in the output.
Finally, the function f is called recursively with the argument n – 1. This means that the function will be called again with a smaller value of n. This recursive call will continue until n becomes less than 0, at which point the base case will be triggered, and the recursion will start unwinding.

Output:

*****
****
***
**
*

Example 4:

#include <iostream>
using namespace std;

void f(int n)
{
    if (n == 0)
        return;
    else
    {
        f(n / 10);
        cout << n % 10 << endl;
    }
}

int main()
{
    f(100);
    return 0;
}

Output:

1
0
0

The function works by recursively calling itself to print the digits of the integer one by one, starting with the least significant digit. The function also divides the integer by 10 on each recursive call to get the next most significant digit.

To print the digits of the integer 1234, we would call the function as follows:

f(1234);

This would cause the function to recursively call itself 4 times, printing a digit to the console each time.

The following table shows the sequence of calls that would be made:

Call	Input number `n`	Output
f(5)	5	*
f(4)	4	*
f(3)	3	*
f(2)	2	*
f(1)	1	*
f(0)	0	(function returns)

The final call to the function with n equal to 0 would cause the function to return, and the sequence of calls would be complete.

Function part 7 (Recursion 2)

Function part 7 (Recursion 2)

CONTENTS