Linear Search Algorithm in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the index of the target element in the array or -1 if not found.

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === [1]) {
      return i;
    }
  }
  return -1;
}

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

Atarget

Barr.length

Carr[i]

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using the loop index i instead of the target value.

Comparing the element to itself instead of the target.

The code compares each element arr[i] with the target. So, the blank must be target to check if the current element matches the target.

2fill in blank

medium

Complete the code to return -1 if the target is not found after checking all elements.

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i;
    }
  }
  return [1];
}

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

A-1

Bundefined

Cnull

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 0 which is a valid index.

Returning null or undefined which are not numbers.

If the target is not found, the function should return -1 to indicate absence.

3fill in blank

hard

Fix the error in the loop condition to avoid going out of array bounds.

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i < [1]; i++) {
    if (arr[i] === target) {
      return i;
    }
  }
  return -1;
}

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

Ai

Btarget

Carr.length - 1

Darr.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using i <= arr.length which is off by one.

Using target or i in the condition incorrectly.

The loop should run while i < arr.length to avoid accessing an index outside the array.

4fill in blank

hard

Fill both blanks to create a function that returns true if the target exists in the array, false otherwise.

DSA Typescript

function contains(arr: number[], target: number): boolean {
  for (let i = 0; i < [1]; i++) {
    if (arr[i] === [2]) {
      return true;
    }
  }
  return false;
}

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

Aarr.length

Btarget

Ci

Darr

Attempts:

3 left

💡 Hint

Common Mistakes

Using i or arr as loop limit.

Comparing with i instead of target.

The loop should run while i < arr.length and compare arr[i] with target to check if the target exists.

5fill in blank

hard

Fill all three blanks to create a function that counts how many times the target appears in the array.

DSA Typescript

function countOccurrences(arr: number[], target: number): number {
  let count = 0;
  for (let i = 0; i < [1]; i++) {
    if (arr[i] === [2]) {
      count[3]1;
    }
  }
  return count;
}

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

Aarr.length

Btarget

C+=

D++

Attempts:

3 left

💡 Hint

Common Mistakes

Using count += 1 is correct but not the expected answer here.

Using wrong loop limit or comparing with wrong variable.

The loop runs while i < arr.length. It compares arr[i] with target. To increase count by one, use count++.

Practice

1. What is the main idea behind the Linear Search Algorithm?

easy

A. Divide the list into halves repeatedly to find the target

B. Check each element one by one until the target is found or list ends

C. Sort the list first then search using binary steps

D. Use a hash table to find the target instantly

Solution

1. Step 1: Understand linear search process

   Linear search checks each element in order, from start to end, to find the target.

2. Step 2: Compare with other search methods

   Binary search divides list, hash uses extra memory, but linear search is simple sequential check.

3. Final Answer:

   Check each element one by one until the target is found or list ends -> Option B

4. Quick Check:

   Linear search = sequential check [OK]

Hint: Linear search means checking items one by one [OK]

Common Mistakes:

• Confusing linear search with binary search
• Thinking linear search requires sorted list
• Assuming linear search is always fastest

2. Which of the following is the correct TypeScript syntax to start a linear search loop over an array arr?

easy

A. for (let i = 0; i < arr.length; i++)

B. for (let i = 1; i <= arr.length; i++)

C. for (let i = 0; i <= arr.length; i++)

D. for (let i = 1; i < arr.length; i++)

Solution

1. Step 1: Identify correct loop start and end

   Array indices start at 0 and go up to length-1, so loop must start at 0 and run while i < length.

2. Step 2: Check each option's loop condition

   for (let i = 0; i < arr.length; i++) uses i=0 and i < arr.length, which is correct. Others either start at 1 or use <= which causes out-of-bounds.

3. Final Answer:

   for (let i = 0; i < arr.length; i++) -> Option A

4. Quick Check:

   Loop from 0 to length-1 [OK]

Hint: Array loops start at 0 and run while less than length [OK]

Common Mistakes:

• Starting loop at 1 instead of 0
• Using <= instead of < causing index errors
• Confusing array length with last index

3. What will be the output of this TypeScript code?

const arr = [4, 7, 1, 9];
const target = 1;
let index = -1;
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

medium

A. 1

B. -1

C. 2

D. 3

Solution

1. Step 1: Trace the loop and compare elements

   Check arr[0]=4 (not 1), arr[1]=7 (not 1), arr[2]=1 (match found), set index=2 and break loop.

2. Step 2: Output the index variable

   After loop, index is 2, so console.log prints 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Target found at index 2 [OK]

Hint: Stop at first match and print its index [OK]

Common Mistakes:

• Not breaking loop and returning last index
• Confusing index with value
• Assuming index starts at 1

4. Find the error in this linear search code snippet and choose the fix:

const arr = [5, 3, 8];
const target = 3;
let index = -1;
for (let i = 0; i <= arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

medium

A. Change loop condition to i < arr.length

B. Initialize index to 0 instead of -1

C. Remove the break statement

D. Change target to 5

Solution

1. Step 1: Identify loop boundary error

   The loop uses i <= arr.length, which causes i to reach arr.length, an invalid index (out of bounds).

2. Step 2: Fix loop condition to prevent out-of-bounds

   Changing condition to i < arr.length ensures i stays within valid indices 0 to length-1.

3. Final Answer:

   Change loop condition to i < arr.length -> Option A

4. Quick Check:

   Loop must run while i < length [OK]

Hint: Use < not <= for array index loops [OK]

Common Mistakes:

• Using <= causing runtime error
• Changing unrelated variables
• Removing break causing unnecessary iterations

5. You want to find the last occurrence of a target number in an array using linear search. Which modification to this code will achieve that?

const arr = [2, 5, 3, 5, 7];
const target = 5;
let index = -1;
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

hard

A. Sort the array before searching

B. Add break after setting index to stop at first occurrence

C. Start loop from the end and break at first match

D. Remove the break statement to continue searching all elements

Solution

1. Step 1: Understand current code behavior

   The loop checks all elements; each time target matches, index updates to current i, so last match index remains after loop.

2. Step 2: Identify why removing break helps

   If break was present, loop would stop at first match. Removing break ensures full array is checked for last occurrence.

3. Final Answer:

   Remove the break statement to continue searching all elements -> Option D

4. Quick Check:

   Keep searching to find last occurrence [OK]

Hint: To find last occurrence, check all elements without break [OK]

Common Mistakes:

• Adding break stops search too early
• Sorting changes original order and index meaning
• Starting loop from end requires different logic