AAWZRSSZX

GGGB

int main() {
// Create a sample linked list
Node* head = new Node{1, nullptr};
head->next = new Node{2, nullptr};
head->next->next = new Node{3, nullptr};
head->next->next->next = new Node{4, nullptr};

int length = getLinkedListLength(head);

std::cout << "Length of the linked list: " << length << std::endl;

// Don't forget to free the memory allocated for the linked list.
while (head != nullptr) {
Node* temp = head;
head = head->next;
delete temp;
}

return 0;
}

Q:3: What is the output for the following version of reverse():

void reverse() {
int ch;
cin.get(ch);
if (ch != '\n')
reverse();
cout.put(ch);
}
ANS: The given reverse function reads characters from the standard input (e.g., keyboard) and
recursively prints them in reverse order until it encounters a newline character ('\n'). Here's the
behavior of the function:

 It reads a character into the variable ch using cin.get(ch).

 It checks if ch is not equal to '\n'.
 If ch is not equal to '\n', it recursively calls reverse() to read the next character.
 When it reaches the newline character, it starts returning from the recursive calls, and each
character is printed using cout.put(ch), which effectively prints the characters in reverse
order.
For example, if we enter the input "Hello" and then press Enter, the function will print "olleH" as
the output.

Q:4: What is the output of the same function if ch is declared as

static char ch;.
ANS: If we declare `ch` as a `static` character (`static char ch;`), it means that the variable `ch` will
retain its value between function calls. In this case, the `reverse` function would not work as
expected because the `ch` variable's value would persist between calls, and the recursion would
not properly reverse the characters.
Here's what happens with `static char ch;`:

1. The function reads a character into `ch`.

2. It checks if `ch` is not equal to `'\n'`.
3. If `ch` is not equal to `'\n'`, it calls `reverse()` to read the next character.
4. However, because `ch` is `static`, its value persists between function calls. So, when the
recursion unwinds, the same character (the last one read) is printed multiple times.

As a result, the output would not reverse the characters as intended, and we might get duplicate
characters in the output. The exact output would depend on the input and the number of recursive
calls. In most cases, it would not produce the desired reversed output.

Q:5: Write a recursive method that for a positive integer n prints odd numbers
a. between 1 and n
b. between n and 1
ANS: To print odd numbers between 1 and a positive integer `n` and between `n` and 1 using a
recursive method, we can define two separate functions. Here's how we can do it:

a. Printing Odd Numbers between 1 and n:

#include <iostream>

void printOddNumbersFrom1ToN(int n) {
if (n < 1) {
return;
}

if (n % 2 == 1) {
std::cout << n << " ";
}

printOddNumbersFrom1ToN(n - 1);
}

int main() {
int n;
std::cout << "Enter a positive integer (n): ";
std::cin >> n;

std::cout << "Odd numbers between 1 and " << n << ": ";
printOddNumbersFrom1ToN(n);
std::cout << std::endl;

return 0;
}
This code defines a `printOddNumbersFrom1ToN` function that recursively prints odd numbers
from `n` down to 1.

b. Printing Odd Numbers between n and 1:

#include <iostream>

void printOddNumbersFromNTo1(int n) {
if (n < 1) {
return;
}

if (n % 2 == 1) {
std::cout << n << " ";
}

printOddNumbersFromNTo1(n - 1);
}

int main() {
int n;
std::cout << "Enter a positive integer (n): ";
std::cin >> n;

std::cout << "Odd numbers between " << n << " and 1: ";
printOddNumbersFromNTo1(n);
std::cout << std::endl;

return 0;
}

This code defines a `printOddNumbersFromNTo1` function that recursively prints odd numbers
from `n` down to 1.

We can choose which part of the code to use based on whether we want to print odd numbers
from 1 to `n` or from `n` to 1.

Q:6: Write a recursive method that for a positive integer returns a string with commas
in the appropriate places, for example, putCommas(1234567) returns the string
“1,234,567.”
ANS: We can create a recursive method in C++ to insert commas in the appropriate places for a
positive integer. Here's one way to do it:

#include <iostream>
#include <string>
std::string putCommas(int num) {
if (num < 1000) {
// Base case: If the number is less than 1000, simply convert it to a string and return.
return std::to_string(num);
} else {
// Recursive case: Split the number into two parts - the last three digits and the rest.
int lastThreeDigits = num % 1000;
int restOfTheNumber = num / 1000;

// Recursively format the rest of the number and add commas to the last three digits.
std::string formattedRest = putCommas(restOfTheNumber);
std::string formattedLastThree = std::to_string(lastThreeDigits);

// Combine the two parts with a comma in the middle and return.
return formattedRest + "," + (formattedLastThree.length() == 1 ? "00" + formattedLastThree :
(formattedLastThree.length() == 2 ? "0" + formattedLastThree : formattedLastThree));
}
}

int main() {
int number;
std::cout << "Enter a positive integer: ";
std::cin >> number;

if (number >= 0) {
std::string result = putCommas(number);
std::cout << "Formatted number with commas: " << result << std::endl;
} else {
std::cout << "Please enter a non-negative integer." << std::endl;
}

return 0;
}

This code defines a `putCommas` function that recursively inserts commas into a given positive
integer. It separates the number into the last three digits and the rest and recursively formats the
rest. The function returns a string with commas in the appropriate places.

Q:7: Write a recursive method to print a Syracuse sequence that begins with a number n0
and each element ni

of the sequence is ni-1 /2 if ni-1 is even and 3ni-1 + 1 otherwise.

The sequence ends with 1.

ANS: We can create a recursive function in C++ to print the Syracuse sequence for a given starting
number `n0` until it reaches 1. Here's how we can do it:

#include <iostream>
void printSyracuseSequence(int n) {
if (n == 1) {
std::cout << n << std::endl;
} else {
std::cout << n << " ";
if (n % 2 == 0) {
// If n is even, calculate ni-1 / 2 and recurse with the result.
printSyracuseSequence(n / 2);
} else {
// If n is odd, calculate 3ni-1 + 1 and recurse with the result.
printSyracuseSequence(3 * n + 1);
}
}
}

int main() {
int n0;
std::cout << "Enter a starting number (n0): ";
std::cin >> n0;

if (n0 <= 0) {
std::cout << "Please enter a positive integer for n0." << std::endl;
} else {
std::cout << "Syracuse sequence for " << n0 << ": ";
printSyracuseSequence(n0);
}

return 0;
}

In this code:

- The `printSyracuseSequence` function takes an integer `n` and recursively calculates the Syracuse
sequence until it reaches 1, printing each element in the sequence.

- If the current number is 1, it prints 1 and terminates the recursion.

- Otherwise, it prints the current number, and based on whether it's even or odd, it calculates the
next number in the sequence and recursively calls `printSyracuseSequence` with that number.

- The main function takes the starting number `n0` as input and initiates the Syracuse sequence for
that number.

This code will print the Syracuse sequence starting from the given `n0` and ending with 1.

Q:8: Write a recursive method that uses only addition, subtraction, and comparison to
multiply two numbers.
ANS: We can implement a recursive method to multiply two numbers using only addition,
subtraction, and comparison. One common algorithm for this is the Russian Peasant Multiplication
method. Here's a C++ implementation:

#include <iostream>

int multiply(int a, int b) {

// Base case: If one of the numbers is 0, the product is 0.
if (a == 0 || b == 0) {
return 0;
}

// If 'b' is odd, subtract 'a' from the result and recursively multiply 'a' and 'b' by halving 'b'.
if (b % 2 == 1) {
return a + multiply(a, b - 1);
}
// If 'b' is even, double 'a' and halve 'b' to recursively multiply.
else {
return multiply(a * 2, b / 2);
}
}

int main() {
int num1, num2;
std::cout << "Enter two numbers to multiply: ";
std::cin >> num1 >> num2;

int result = multiply(num1, num2);

std::cout << "Product: " << result << std::endl;

return 0;
}

In this code:

- The `multiply` function recursively calculates the product of two numbers `a` and `b`.
- If one of the numbers is 0, the function returns 0 (base case).
- If `b` is odd, it subtracts `a` from the result and recursively multiplies `a` by reducing `b` by 1.
- If `b` is even, it doubles `a` and reduces `b` by half and recursively multiplies.
- The main function takes two numbers as input and calls the `multiply` function to compute the
product.

This recursive algorithm effectively multiplies two numbers using only addition, subtraction, and
comparison.
Q:9: Write a recursive function to compute the binomial coefficient according to the
definition:
C(n, k) = 1 if k is 0 or k is equal to n.
C(n, k) = C(n - 1, k - 1) + C(n - 1, k) otherwise.
ANS: We can compute the binomial coefficient using a recursive function according to the given
definition. The binomial coefficient, denoted as C(n, k), can be calculated as follows:

C(n, k) = 1 if k is 0 or k is equal to n.
C(n, k) = C(n - 1, k - 1) + C(n - 1, k) otherwise.

Here's a C++ implementation of a recursive function to compute the binomial coefficient based on
this definition:

#include <iostream>

int binomialCoefficient(int n, int k) {

if (k == 0 || k == n) {
return 1;
} else {
return binomialCoefficient(n - 1, k - 1) + binomialCoefficient(n - 1, k);
}
}

int main() {
int n, k;
std::cout << "Enter values for n and k: ";
std::cin >> n >> k;

if (k < 0 || k > n) {
std::cout << "Invalid input. k must be between 0 and n." << std::endl;
} else {
int result = binomialCoefficient(n, k);
std::cout << "C(" << n << ", " << k << ") = " << result << std::endl;
}

return 0;
}

In this code:

- The `binomialCoefficient` function recursively calculates the binomial coefficient using the
definition provided.
- If k is 0 or k is equal to n, it returns 1 (base case).
- Otherwise, it recursively calculates C(n - 1, k - 1) and C(n - 1, k) and adds them together.

The main function takes input for n and k, performs input validation, and then computes and
prints the binomial coefficient.
Q:10: Write a recursive function to add the first n terms of the series
1 + 1/2 - 1/3 + 1/4 - 1/5....
ANS: We can write a recursive function in C++ to add the first `n` terms of the series 1 + 1/2 - 1/3 +
1/4 - 1/5... Here's how we can do it:

#include <iostream>

double calculateSeries(int n, int currentTerm, double currentSum, bool isPositive) {

if (currentTerm > n) {
return currentSum;
} else {
double term = 1.0 / currentTerm;

if (!isPositive) {
term = -term;
}

return calculateSeries(n, currentTerm + 1, currentSum + term, !isPositive);

}
}

double sumSeries(int n) {
if (n < 1) {
std::cerr << "Invalid input. n should be a positive integer." << std::endl;
return 0.0;
}

return calculateSeries(n, 1, 0.0, true);

}

int main() {
int n;
std::cout << "Enter the number of terms (n): ";
std::cin >> n;

double result = sumSeries(n);

std::cout << "Sum of the first " << n << " terms: " << result << std::endl;

return 0;
}

In this code:

- `calculateSeries` is a recursive function that calculates the sum of the series up to the `n`-th term.
It uses a `currentTerm` to keep track of the current term, `currentSum` to accumulate the sum, and
`isPositive` to determine whether the current term is positive or negative.

- `sumSeries` is a wrapper function that validates the input `n` and initiates the recursive
calculation.
- The `main` function takes input for `n`, checks if it's a valid input, and then calculates and prints
the sum of the series.

This code will compute the sum of the first `n` terms of the series as specified.

Q:11: Write a recursive function GCD(n,m) that returns the greatest common divisor of
two integers n and m according to the following definition:

ANS: We can write a recursive function to calculate the greatest common divisor (GCD) of two
integers `n` and `m` based on the definition we provided. Here's a C++ implementation of such a
function:

#include <iostream>

int GCD(int n, int m) {

if (m <= n && n % m == 0) {
return m;
} else if (n < m) {
return GCD(m, n);
} else {
return GCD(m, n % m);
}
}

int main() {
int n, m;
std::cout << "Enter two integers (n and m): ";
std::cin >> n >> m;

if (n < 0 || m < 0) {
std::cerr << "Both n and m should be non-negative integers." << std::endl;
} else {
int result = GCD(n, m);
std::cout << "GCD(" << n << ", " << m << ") = " << result << std::endl;
}

return 0;
}

In this code:

- The `GCD` function calculates the GCD of `n` and `m` using the definition we provided. It checks
whether `m` is less than or equal to `n` and whether `n` is divisible by `m`. If so, it returns `m`. If `n`
is less than `m`, it swaps `n` and `m` and continues the calculation. Otherwise, it recursively
computes the GCD of `m` and `n % m`.
- The `main` function takes input for `n` and `m`, checks if they are non-negative integers, and then
calculates and prints the GCD.

This code will compute the GCD of two integers `n` and `m` based on the provided definition.

Q:12: Give a recursive version of the following function:

void cubes (int n) {
for (int i = 1; i <= n; i++)
cout << i * i * i << ’’;
}
ANS: We can create a recursive version of the `cubes` function by replacing the `for` loop with
recursion. Here's a recursive version in C++:

#include <iostream>

void printCubes(int n, int i = 1) {

if (i <= n) {
std::cout << i * i * i << " ";
printCubes(n, i + 1);
}
}

int main() {
int n;
std::cout << "Enter a positive integer (n): ";
std::cin >> n;

if (n <= 0) {
std::cerr << "Please enter a positive integer." << std::endl;
} else {
std::cout << "Cubes of numbers from 1 to " << n << ": ";
printCubes(n);
std::cout << std::endl;
}

return 0;
}

In this code:

- The `printCubes` function is a recursive function that takes two parameters: `n` (the upper limit)
and `i` (the current number being processed).

- It checks if `i` is less than or equal to `n`. If true, it prints the cube of `i` and makes a recursive call
with `i` incremented by 1.
- The `main` function takes input for `n`, checks if it's a positive integer, and then calls the
`printCubes` function to print the cubes of numbers from 1 to `n`.

This code provides a recursive version of the original `cubes` function that prints the cubes of
numbers from 1 to `n`.

Q:13: Check recursively if the following objects are palindromes:

a. a word
b. a sentence (ignoring blanks, lower- and uppercase differences, and punctuation
marks so that “Madam, I’m Adam” is accepted as a palindrome)
ANS: To check if a word or a sentence is a palindrome recursively, we can follow these steps for
each case:

a. Checking if a Word is a Palindrome:

#include <iostream>
#include <cctype>
#include <string>

bool isPalindromeWord(const std::string& word) {

// Base case: If the word has 0 or 1 character, it's a palindrome.
if (word.length() <= 1) {
return true;
}

// Remove non-alphabet characters and convert to lowercase.

std::string cleanWord;
for (char c : word) {
if (std::isalpha(c)) {
cleanWord += std::tolower(c);
}
}

// Compare the first and last characters.

if (cleanWord.front() == cleanWord.back()) {
// Recurse with the middle part of the word.
return isPalindromeWord(cleanWord.substr(1, cleanWord.length() - 2));
}

return false;
}

int main() {
std::string word;
std::cout << "Enter a word to check if it's a palindrome: ";
std::cin >> word;

if (isPalindromeWord(word)) {
std::cout << "It's a palindrome." << std::endl;
} else {
std::cout << "It's not a palindrome." << std::endl;
 }

return 0;
}

This code checks if a single word is a palindrome by removing non-alphabet characters and
ignoring case differences.

b. Checking if a Sentence is a Palindrome:

#include <iostream>
#include <cctype>
#include <string>

bool isPalindromeSentence(const std::string& sentence) {

// Base case: If the sentence has 0 or 1 character, it's a palindrome.
if (sentence.length() <= 1) {
return true;
}

// Remove non-alphabet characters and convert to lowercase.

std::string cleanSentence;
for (char c : sentence) {
if (std::isalpha(c)) {
cleanSentence += std::tolower(c);
}
}

// Compare the first and last characters.

if (cleanSentence.front() == cleanSentence.back()) {
// Recurse with the middle part of the sentence.
return isPalindromeSentence(cleanSentence.substr(1, cleanSentence.length() - 2));
}

return false;
}

int main() {
std::string sentence;
std::cout << "Enter a sentence to check if it's a palindrome: ";
std::getline(std::cin, sentence);

if (isPalindromeSentence(sentence)) {
std::cout << "It's a palindrome." << std::endl;
} else {
std::cout << "It's not a palindrome." << std::endl;
}
 return 0;
}

This code checks if a sentence is a palindrome by removing non-alphabet characters, ignoring case
differences, and spaces. It uses recursion to check if the cleaned sentence is a palindrome.

Q:14: For a given character recursively, without using strchr() or strrchr(),

a. Check if it is in a string.
b. Count all of its occurrences in a string.
c. Remove all of its occurrences from a string.
ANS: To perform these operations recursively without using `strchr()`, `strrchr()`, or similar
standard library functions, we can create custom recursive functions. Here's how we can do each
of the operations:

a. Check if a character is in a string:

#include <iostream>

bool isCharacterInString(const std::string& str, char ch, int index = 0) {

if (index == str.length()) {
return false;
}

if (str[index] == ch) {
return true;
}

return isCharacterInString(str, ch, index + 1);

}

int main() {
std::string str;
char ch;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a character to check: ";
std::cin >> ch;

if (isCharacterInString(str, ch)) {
std::cout << "The character is in the string." << std::endl;
} else {
std::cout << "The character is not in the string." << std::endl;
}

return 0;
}
b. Count all occurrences of a character in a string:

#include <iostream>

int countCharacterOccurrences(const std::string& str, char ch, int index = 0) {

if (index == str.length()) {
return 0;
}

int count = (str[index] == ch) ? 1 : 0;

return count + countCharacterOccurrences(str, ch, index + 1);

}

int main() {
std::string str;
char ch;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a character to count: ";
std::cin >> ch;

int count = countCharacterOccurrences(str, ch);

std::cout << "Occurrences of the character: " << count << std::endl;

return 0;
}

c. Remove all occurrences of a character from a string:

#include <iostream>
#include <string>

void removeCharacterFromString(std::string& str, char ch, int index = 0) {

if (index == str.length()) {
return;
}

if (str[index] == ch) {
str.erase(index, 1); // Remove the character at the current index.
} else {
index++;
}
 removeCharacterFromString(str, ch, index);
}

int main() {
std::string str;
char ch;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a character to remove: ";
std::cin >> ch;

removeCharacterFromString(str, ch);
std::cout << "String after removing all occurrences: " << str << std::endl;

return 0;
}

In these examples, we use recursion to check if a character is in a string, count its occurrences, and
remove all occurrences. The last example modifies the original string to remove the character
recursively.

Q:15: Write equivalents of the last three functions for substrings (do not use strstr()).
ANS: To perform operations with substrings without using the `strstr()` function, we can
create custom recursive functions to:

a. Check if a substring is in a string.

b. Count all occurrences of a substring in a string.

c. Remove all occurrences of a substring from a string.

Here's how we can implement each of these operations:

a. Check if a substring is in a string:

#include <iostream>
#include <string>

bool isSubstringInString(const std::string& str, const std::string& substr, int strIndex = 0, int
substrIndex = 0) {
if (substrIndex == substr.length()) {
return true; // Entire substring has been found.
}

if (strIndex == str.length()) {
return false; // Reached the end of the string without finding the entire substring.
}

if (str[strIndex] == substr[substrIndex]) {
 // Recurse with both indices incremented.
return isSubstringInString(str, substr, strIndex + 1, substrIndex + 1);
} else {
// Start searching for the substring from the next position in the string.
return isSubstringInString(str, substr, strIndex - substrIndex + 1, 0);
}
}

int main() {
std::string str;
std::string substr;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a substring to check: ";
std::cin >> substr;

if (isSubstringInString(str, substr)) {
std::cout << "The substring is in the string." << std::endl;
} else {
std::cout << "The substring is not in the string." << std::endl;
}

return 0;
}

b. Count all occurrences of a substring in a string:

#include <iostream>
#include <string>

int countSubstringOccurrences(const std::string& str, const std::string& substr, int strIndex = 0, int
substrIndex = 0) {
if (substrIndex == substr.length()) {
return 1 + countSubstringOccurrences(str, substr, strIndex - substrIndex + 1, 0);
}

if (strIndex == str.length()) {
return 0;
}

if (str[strIndex] == substr[substrIndex]) {
// Continue matching the substring.
return countSubstringOccurrences(str, substr, strIndex + 1, substrIndex + 1);
} else {
// Start searching for the substring from the next position in the string.
return countSubstringOccurrences(str, substr, strIndex - substrIndex + 1, 0);
}
}
int main() {
std::string str;
std::string substr;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a substring to count: ";
std::cin >> substr;

int count = countSubstringOccurrences(str, substr);

std::cout << "Occurrences of the substring: " << count << std::endl;

return 0;
}

c. Remove all occurrences of a substring from a string:

#include <iostream>
#include <string>

void removeSubstringFromString(std::string& str, const std::string& substr, int strIndex = 0, int

substrIndex = 0) {
if (substrIndex == substr.length()) {
str.erase(strIndex - substrIndex, substrIndex); // Remove the matched substring.
}

if (strIndex == str.length()) {
return;
}

if (str[strIndex] == substr[substrIndex]) {
// Continue matching the substring.
removeSubstringFromString(str, substr, strIndex + 1, substrIndex + 1);
} else {
// Start searching for the substring from the next position in the string.
removeSubstringFromString(str, substr, strIndex - substrIndex + 1, 0);
}
}

int main() {
std::string str;
std::string substr;
std::cout << "Enter a string: ";
std::cin >> str;
std::cout << "Enter a substring to remove: ";
std::cin >> substr;

removeSubstringFromString(str, substr);
 std::cout << "String after removing all occurrences: " << str << std::endl;

return 0;
}

In these examples, we use recursion to work with substrings in a string, checking if a substring is
present, counting its occurrences, and removing all occurrences from the string.\

Q:16: Write the shortest program we can that uses recursion.

ANS: A very short recursive program can be one that calculates the factorial of a number. Here's a
short C++ program that calculates the factorial of a number using recursion:

#include <iostream>

unsigned long long factorial(int n) {

if (n == 0 || n == 1) {
return 1;
}
return n * factorial(n - 1);
}

int main() {
int n;
std::cout << "Enter a non-negative integer: ";
std::cin >> n;

if (n < 0) {
std::cerr << "Please enter a non-negative integer." << std::endl;
} else {
unsigned long long result = factorial(n);
std::cout << "Factorial of " << n << " is " << result << std::endl;
}

return 0;
}

This short program calculates the factorial of a non-negative integer using recursion. The `factorial`
function recursively calculates the factorial.