Recursion on Arrays and Strings in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the length of the string using recursion.

DSA Typescript

function recursiveLength(str: string): number {
  if (str === "") {
    return 0;
  }
  return 1 + recursiveLength(str[1]);
}

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

A.slice(1)

B.charAt(1)

C.substring(0, 1)

D.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using str.length instead of slicing the string.

Using substring(0,1) which returns the first character, not the rest.

We use str.slice(1) to get the string without the first character and call recursion on it.

2fill in blank

medium

Complete the code to check if an array contains a target value using recursion.

DSA Typescript

function contains(arr: number[], target: number, index: number = 0): boolean {
  if (index === arr.length) {
    return false;
  }
  if (arr[1] === target) {
    return true;
  }
  return contains(arr, target, index + 1);
}

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

A.index

B[index]

C(index)

D{index}

Attempts:

3 left

💡 Hint

Common Mistakes

Using dot notation which is invalid for array indexing.

Using parentheses which is function call syntax.

We access the element at the current index using arr[index] to compare with the target.

3fill in blank

hard

Fix the error in the recursive function that reverses a string.

DSA Typescript

function reverseString(str: string): string {
  if (str.length === 0) {
    return "";
  }
  return reverseString(str[1]) + str.charAt(0);
}

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

A.slice(1)

B.charAt(1)

C.substring(1)

D.slice(0, 1)

Attempts:

3 left

💡 Hint

Common Mistakes

Using substring(1) works but slice(1) is preferred for clarity.

Using slice(0,1) returns the first character, not the rest.

We use str.slice(1) to get the string without the first character for recursion.

4fill in blank

hard

Fill both blanks to create a recursive function that sums all elements in an array.

DSA Typescript

function sumArray(arr: number[], index: number = 0): number {
  if (index [1] arr.length) {
    return 0;
  }
  return arr[2] + sumArray(arr, index + 1);
}

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

A<

B>

C[index]

D.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' in the base case condition.

Using dot notation instead of square brackets for array access.

We check if index is less than array length and access element at arr[index].

5fill in blank

hard

Fill all three blanks to create a recursive function that counts how many times a character appears in a string.

DSA Typescript

function countChar(str: string, char: string, index: number = 0): number {
  if (index [1] str.length) {
    return 0;
  }
  const count = (str.charAt(index) === char) ? [2] : 0;
  return count + countChar(str, char, index [3] 1);
}

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

A<

B1

C+

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' in the base case.

Adding 0 instead of 1 when characters match.

Using '-' instead of '+' to increment index.

We check if index is less than string length, add 1 if characters match, and increment index by 1.

Practice

1. What does a recursive function on an array typically do?

easy

A. It only works on strings, not arrays.

B. It loops through the array without calling itself.

C. It creates a new array without using recursion.

D. It calls itself with a smaller part of the array until a base case is reached.

Solution

1. Step 1: Understand recursion on arrays

   Recursive functions on arrays call themselves with smaller parts of the array to solve the problem step-by-step.

2. Step 2: Identify the base case

   The recursion stops when the array is empty or has one element, which is the base case.

3. Final Answer:

   It calls itself with a smaller part of the array until a base case is reached. -> Option D

4. Quick Check:

   Recursion = smaller parts + base case [OK]

Hint: Recursion breaks problem into smaller parts until simple case [OK]

Common Mistakes:

• Thinking recursion loops without calling itself
• Confusing recursion with iteration
• Believing recursion only works on strings

2. Which of the following is the correct TypeScript syntax to define a recursive function that sums elements of a number array?

easy

A. function sum(arr: number[]): number { return arr[0] + sum(arr.slice(1)); }

B. function sum(arr: number[]): number { if(arr.length === 0) return 1; return arr[0] + sum(arr.slice(1)); }

C. function sum(arr: number[]): number { if(arr.length === 0) return 0; return arr[0] + sum(arr.slice(1)); }

D. function sum(arr: number[]): number { if(arr.length === 0) return 0; return sum(arr.slice(1)); }

Solution

1. Step 1: Check base case correctness

   The base case should return 0 when array is empty to stop recursion correctly.

2. Step 2: Check recursive call and addition

   The function adds the first element to the sum of the rest of the array recursively.

3. Final Answer:

   function sum(arr: number[]): number { if(arr.length === 0) return 0; return arr[0] + sum(arr.slice(1)); } -> Option C

4. Quick Check:

   Base case returns 0 + recursive sum [OK]

Hint: Base case returns 0; recursive call adds first element [OK]

Common Mistakes:

• Missing base case causing infinite recursion
• Returning wrong base case value like 1
• Not adding the first element before recursive call

3. What is the output of this TypeScript code?

function reverseString(s: string): string {
  if (s === "") return "";
  return reverseString(s.slice(1)) + s[0];
}
console.log(reverseString("abc"));

medium

A. "cba"

B. "abc"

C. "bac"

D. Runtime error

Solution

1. Step 1: Trace recursive calls

   reverseString("abc") calls reverseString("bc") + "a"; reverseString("bc") calls reverseString("c") + "b"; reverseString("c") calls reverseString("") + "c".

2. Step 2: Build return values from base case

   reverseString("") returns ""; so reverseString("c") returns "" + "c" = "c"; reverseString("bc") returns "c" + "b" = "cb"; reverseString("abc") returns "cb" + "a" = "cba".

3. Final Answer:

   "cba" -> Option A

4. Quick Check:

   Reverse "abc" = "cba" [OK]

Hint: Recursion reverses string by slicing first char off [OK]

Common Mistakes:

• Confusing order of concatenation
• Forgetting base case returns empty string
• Expecting original string as output

4. Identify the error in this recursive function that counts occurrences of a number in an array:

function countOccurrences(arr: number[], target: number): number {
  if (arr.length === 0) return 0;
  if (arr[0] === target) return 1 + countOccurrences(arr.slice(1), target);
}

medium

A. Missing else case to handle when arr[0] !== target

B. Base case should return 1 instead of 0

C. Function should not use recursion

D. arr.slice(1) is incorrect syntax

Solution

1. Step 1: Check base case and recursive calls

   Base case returns 0 correctly when array is empty. When arr[0] equals target, function returns 1 plus recursive call.

2. Step 2: Identify missing return for else case

   If arr[0] is not target, function does not return anything, causing undefined result and error.

3. Final Answer:

   Missing else case to handle when arr[0] !== target -> Option A

4. Quick Check:

   All paths must return a value [OK]

Hint: Ensure all if branches return a value in recursion [OK]

Common Mistakes:

• Forgetting else return causes undefined
• Changing base case incorrectly
• Thinking recursion is not needed

5. Given a nested array of numbers like [1, [2, [3, 4], 5], 6], which recursive approach correctly flattens it into [1, 2, 3, 4, 5, 6]?

hard

A. Return the array as is without changes.

B. Check if element is array; if yes, recursively flatten it and concatenate; else add element to result.

C. Use a loop to add elements without recursion.

D. Only flatten one level of nested arrays without recursion.

Solution

1. Step 1: Understand nested array flattening

   Flattening requires checking each element; if it is an array, recursively flatten it to handle any depth.

2. Step 2: Build flattened array by concatenation

   For non-array elements, add directly; for arrays, concatenate their flattened results to build final flat array.

3. Final Answer:

   Check if element is array; if yes, recursively flatten it and concatenate; else add element to result. -> Option B

4. Quick Check:

   Recursion handles any depth flattening [OK]

Hint: Recursively flatten nested arrays by checking element type [OK]

Common Mistakes:

• Flattening only one level deep
• Not checking if element is array
• Using loops without recursion for nested arrays