Recursion. Classic recursion problems

# Sum of Integers from 1 to N

| | |
| :--- | :--- |
| **Input** | Standard input |
| **Output** | Standard output |

### Problem Statement
Given a natural number $N$, find the sum of all integers from 1 to $N$.

### Input Format
The input consists of a single natural number $N$ ($N < 1000$).

### Output Format
Print a single value — the sum of all integers from 1 to $N$.

### Examples
| Input | Output |
| :--- | :--- |
| `5` | `15` |
| `10` | `55` |

#include <iostream>

using namespace std;

int sum1toN(int n) {
    if (n == 1) return 1;
    return n + sum1toN(n - 1);
}

int main() {
    int N;
    cin >> N;
    cout << sum1toN(N) << endl;
    return 0;
}


# Recursive Power

| | |
| :--- | :--- |
| **Input** | Standard input |
| **Output** | Standard output |

### Problem Statement
Implement a function for recursive exponentiation of a real number.

### Input Format
The first and only line of input contains a real number $x$ and an integer $p$ ($0 \le p \le 10, |x| \le 1000, x \neq 0$), representing the exponent.

### Output Format
Print $x^p$ with a precision of at least 6 decimal places. It is guaranteed that the absolute value of the result does not exceed $1,000,000$.

### Notes
If you are solving this problem using Python, you may store both input parameters as `float`.

### Examples
| Input | Output |
| :--- | :--- |
| `2.0 10` | `1024.0000000000` |
| `-1.0 3` | `-1.0000000000` |

#include <iostream>
#include <iomanip>

using namespace std;

double p(double a, int b) {
    if (b == 0)
      return 1.0;
    return a * p(a, b - 1);
}

int main() {
    double a;
    int b;
    cin >> a >> b;

    double c = p(a, b);
    cout << fixed << setprecision(6) << c << endl;

    return 0;
}

# Recursive Exponentiation

***

### Problem Statement
Implement a recursive function to raise a real number to a power.

***

### Input Format
The first and only line of input contains a real number $x$ and an integer $p$ ($0 \le p \le 10, |x| \le 1000, x \neq 0$), which is the exponent.

***

### Output Format
Print the result of $x^p$ with a precision of at least 6 decimal places. It is guaranteed that the absolute value of the answer does not exceed $1,000,000$.

***

### Notes
If you are solving this problem using Python, you may store both input parameters as `float`.

***

### Examples
| Input | Output |
| :--- | :--- |
| `2.0 10` | `1024.0000000000` |
| `-1.0 3` | `-1.0000000000` |

#include <iostream>
#include <iomanip>

using namespace std;

double p(double a, int b) {
    if (b == 0)
      return 1.0;
    return a * p(a, b - 1);
}

int main() {
    double a;
    int b;
    cin >> a >> b;

    double c = p(a, b);
    cout << fixed << setprecision(6) << c << endl;

    return 0;
}


# Recursive Factorial

| | |
| :--- | :--- |
| **Input** | Standard input |
| **Output** | Standard output |

### Problem Statement
Implement a recursive function to calculate the factorial of a natural number:
- For **C++**: `int factorial(int a)`
- For **Python**: `factorial(a)`

The factorial of a number is the product of all natural numbers less than or equal to it. For example, $5! = 5 \cdot 4 \cdot 3 \cdot 2 \cdot 1$.

### Input Format
The program receives a single integer $n$ ($1 \le n \le 8$).

### Output Format
Print a single integer — the factorial of $n$.

### Notes
**Important:** Submit only the function for verification.

### Examples
| Input | Output |
| :--- | :--- |
| `3` | `6` |
| `4` | `24` |

#include <iostream>
using namespace std;
int factorial(int a) {
    if (a == 1) return 1;
    return a * factorial(a - 1);
}

int main(){
    int n;
    cin >> n;
    cout << factorial(n);
    return 0;
}


# Recursive Digit Count

| | |
| :--- | :--- |
| **Input** | Standard input |
| **Output** | Standard output |

### Problem Statement
Write a recursive function to count the number of digits in a natural number.

### Input Format
The program receives a single natural number $n$ ($1 \le n \le 2^{16} - 1$).

### Output Format
Print a single integer — the number of digits in $n$.

### Examples
| Input | Output |
| :--- | :--- |
| `412` | `3` |
| `7777` | `4` |

#include <iostream>
using namespace std;

int countDigits(int n) {
    
    if (n < 10) {
        return 1;
    }
    
    return 1 + countDigits(n / 10);
}

int main() {
    int n;
    cin >> n;
    cout << countDigits(n) << endl;
    return 0;
}


# Recursive Sum of Digits

| | |
| :--- | :--- |
| **Input** | Standard input |
| **Output** | Standard output |

### Problem Statement
Write a recursive function to calculate the sum of the digits of a natural number.

### Input Format
The program receives a single natural number $n$ ($n < 2^{16}$).

### Output Format
Print a single integer — the sum of the digits of $n$.

### Examples
| Input | Output |
| :--- | :--- |
| `412` | `7` |
| `777` | `21` |

#include <iostream>

using namespace std;

int sumDigits(int n) {
    if (n < 10)
      return n;
    return (n % 10) + sumDigits(n / 10);
}

int main() {
    int n;
    cin >> n;
    cout << sumDigits(n) << endl;
    return 0;
}