Recursion on Arrays and Strings in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the sum of all elements in the array using recursion.

DSA C#

int SumArray(int[] arr, int index) {
    if (index == arr.Length) {
        return 0;
    }
    return arr[index] + [1];
}

Drag options to blanks, or click blank then click option'

ASumArray(arr, index + 1)

BSumArray(arr, index - 1)

CSumArray(arr, index)

DSumArray(arr, 0)

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same index in the recursive call causes infinite recursion.

Decreasing the index leads to invalid array access.

The function calls itself with the next index to sum all elements recursively.

2fill in blank

medium

Complete the code to check if a string is a palindrome using recursion.

DSA C#

bool IsPalindrome(string s, int start, int end) {
    if (start >= end) {
        return true;
    }
    if (s[start] != s[end]) {
        return false;
    }
    return [1];
}

Drag options to blanks, or click blank then click option'

AIsPalindrome(s, start, end - 1)

BIsPalindrome(s, start + 1, end)

CIsPalindrome(s, start + 1, end - 1)

DIsPalindrome(s, start, end)

Attempts:

3 left

💡 Hint

Common Mistakes

Only moving one pointer causes incorrect checks.

Not moving pointers leads to infinite recursion.

The function moves inward by increasing start and decreasing end to check characters recursively.

3fill in blank

hard

Fix the error in the recursive function that counts occurrences of a character in a string.

DSA C#

int CountChar(string s, char c, int index) {
    if (index == s.Length) {
        return 0;
    }
    int count = (s[index] == c) ? 1 : 0;
    return count + [1];
}

Drag options to blanks, or click blank then click option'

ACountChar(s, c, index - 1)

BCountChar(s, c, index + 1)

CCountChar(s, c, index)

DCountChar(s, c, 0)

Attempts:

3 left

💡 Hint

Common Mistakes

Decreasing the index causes invalid access and infinite recursion.

Using the same index causes infinite recursion.

The function should move forward by increasing the index to count all occurrences correctly.

4fill in blank

hard

Fill both blanks to create a recursive function that reverses a string.

DSA C#

string ReverseString(string s, int start, int end) {
    if (start >= end) {
        return s;
    }
    char temp = s[start];
    s = s.Remove(start, 1).Insert(start, s[end].ToString());
    s = s.Remove(end, 1).Insert(end, temp.ToString());
    return ReverseString(s, [1], [2]);
}

Drag options to blanks, or click blank then click option'

Astart + 1

Bstart - 1

Cend - 1

Dend + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Moving pointers in the wrong direction causes infinite recursion.

Not updating pointers causes the same characters to be swapped repeatedly.

The function moves inward by increasing start and decreasing end to swap characters recursively.

5fill in blank

hard

Fill all three blanks to create a recursive function that builds a dictionary of word lengths for words longer than 3 characters.

DSA C#

Dictionary<string, int> WordLengths(List<string> words) {
    if (words.Count == 0) {
        return new Dictionary<string, int>();
    }
    var result = WordLengths(words.GetRange(1, words.Count - 1));
    string word = words[0];
    if (word.Length > 3) {
        result[[1]] = [2];
    }
    return result;
}

// Usage: var lengths = WordLengths(new List<string> {"apple", "bat", "carrot"});

Drag options to blanks, or click blank then click option'

Aword

Bword.Length

Cwords[0]

Dwords.Count

Attempts:

3 left

💡 Hint

Common Mistakes

Using the list name instead of the current word as the key.

Using the count of words instead of the length of the word.

The dictionary key is the current word, and the value is its length. The word is accessed as 'word'.

Practice

1. What is the main idea behind using recursion on arrays or strings?

easy

A. Sorting the array or string before processing

B. Using loops to iterate over each element

C. Breaking the problem into smaller similar problems until a base case is reached

D. Storing all elements in a new data structure

Solution

1. Step 1: Understand recursion concept

   Recursion solves problems by calling itself with smaller inputs until a simple base case is reached.

2. Step 2: Apply to arrays or strings

   For arrays or strings, recursion processes one element and then calls itself on the rest.

3. Final Answer:

   Breaking the problem into smaller similar problems until a base case is reached -> Option C

4. Quick Check:

   Recursion = divide and conquer [OK]

Hint: Think: solve small part, then repeat on smaller input [OK]

Common Mistakes:

• Confusing recursion with loops
• Ignoring the base case
• Trying to process all elements at once

2. Which of the following is the correct base case for a recursive function that processes a string character by character?

easy

A. if (str[0] == '\0') return;

B. if (str == null) return;

C. if (str.Length > 0) return;

D. if (str.Length == 0) return;

Solution

1. Step 1: Identify base case for string recursion

   The base case should stop recursion when the string is empty (length zero).

2. Step 2: Check options

   if (str.Length == 0) return; correctly checks if string length is zero to stop recursion.

3. Final Answer:

   if (str.Length == 0) return; -> Option D

4. Quick Check:

   Base case = empty string check [OK]

Hint: Base case usually checks for empty string or array length zero [OK]

Common Mistakes:

• Checking for null instead of empty string
• Using wrong condition like length > 0
• Checking for null character '\0' in C# strings

3. What will be the output of this C# recursive function call?

static int SumArray(int[] arr, int index) {
  if (index == arr.Length) return 0;
  return arr[index] + SumArray(arr, index + 1);
}

int[] nums = {1, 2, 3};
Console.WriteLine(SumArray(nums, 0));

medium

A. 6

B. 0

C. 3

D. StackOverflowException

Solution

1. Step 1: Trace recursive calls

   SumArray called with index 0 returns arr[0] + SumArray(1) = 1 + ... SumArray(1) returns 2 + SumArray(2) SumArray(2) returns 3 + SumArray(3) SumArray(3) returns 0 (base case)

2. Step 2: Calculate total sum

   Sum = 1 + 2 + 3 + 0 = 6

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Sum of [1,2,3] = 6 [OK]

Hint: Add current element + recursive sum of rest [OK]

Common Mistakes:

• Forgetting base case leads to infinite recursion
• Returning wrong index or value
• Confusing index with length

4. Identify the error in this recursive function that reverses a string:

static string Reverse(string s) {
  if (s.Length == 0) return s;
  return Reverse(s.Substring(1)) + s[0];
}

// Usage: Console.WriteLine(Reverse(null));

medium

A. It causes a NullReferenceException when input is null

B. It never reaches the base case

C. It returns the original string without reversing

D. It causes infinite recursion

Solution

1. Step 1: Analyze input null handling

   The function calls s.Length but if s is null, this causes NullReferenceException.

2. Step 2: Check base case and usage

   Base case is correct for empty string but does not handle null input, causing runtime error.

3. Final Answer:

   It causes a NullReferenceException when input is null -> Option A

4. Quick Check:

   Null input causes exception [OK]

Hint: Always check for null before accessing string properties [OK]

Common Mistakes:

• Not checking for null input
• Assuming empty string and null are same
• Ignoring exceptions from null dereference

5. Given a string, write a recursive function to check if it is a palindrome (reads same forward and backward). Which of these approaches is correct?

hard

A. Use recursion to sort the string and compare with original

B. Check if first and last characters are equal, then recurse on substring excluding them

C. Count characters recursively and check if count is even

D. Reverse the string using recursion and compare with original

Solution

1. Step 1: Understand palindrome check logic

   Palindrome means first and last characters match, and inner substring is also palindrome.

2. Step 2: Apply recursion

   Recursively check first and last chars, then call function on substring excluding them until base case (empty or single char).

3. Final Answer:

   Check if first and last characters are equal, then recurse on substring excluding them -> Option B

4. Quick Check:

   Palindrome check = compare ends + recurse [OK]

Hint: Compare ends, then recurse inside substring [OK]

Common Mistakes:

• Reversing string is less efficient
• Counting characters doesn't prove palindrome
• Sorting changes string order