JavaScript Coding Test Course, Finding Desired Integer

Problem Description

Implement a function that finds a specific integer in a given array and returns the index of that integer. If the specific integer is not in the array, it should return -1.

The function definition is as follows:

function findInteger(arr: number[], target: number): number

Input:

• arr: An array of integers to search (0 ≤ arr.length ≤ 10^5)
• target: The integer to find (-10^9 ≤ target ≤ 10^9)

Output:

• If target exists in arr, return the index of target
• If target does not exist in arr, return -1

Problem Analysis

To understand the problem, it is helpful to look at some examples of the input array.

• Example 1: findInteger([1, 2, 3, 4, 5], 3) → Output: 2 (index of 3)
• Example 2: findInteger([10, 20, 30], 25) → Output: -1 (25 is not in the array)
• Example 3: findInteger([1, 2, 3, 4, 5], 5) → Output: 4 (index of 5)

This problem involves finding a specific integer in an array of integers, so the most common method would be to traverse the array to find that integer. However, in the worst-case scenario, the array can be up to 100,000 in length, so an efficient solution is needed.

Solution Approach

To solve this problem, we can consider two approaches:

• Linear search (O(n))
• Binary search (O(log n) if the array is sorted)

Linear search is a method of traversing through all elements of the array and comparing them. This method is simple to implement, but in the worst case, it takes O(n) time. However, binary search is only possible if the given array is sorted. Therefore, we cannot exclude the possibility that the array may not be sorted in this problem. Hence, we will choose the linear search method.

Implementation

Below is a specific example of the function’s implementation:

function findInteger(arr, target) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === target) {
            return i; // Return index when the target is found
        }
    }
    return -1; // Return -1 if the target is not found
}
            

The code goes through the following process:

1. It traverses the given array arr using a for loop.
2. It compares each element arr[i] to target.
3. If they match, it returns the corresponding index i.
4. If it reaches the end of the array without finding the target, it returns -1.

Now let’s test this function:

console.log(findInteger([1, 2, 3, 4, 5], 3)); // 2
console.log(findInteger([10, 20, 30], 25)); // -1
console.log(findInteger([1, 2, 3, 4, 5], 5)); // 4
            

Time Complexity Analysis

The time complexity of the above algorithm is O(n). The maximum number of searches required is proportional to the length of the array. In the worst case, all elements of the array may need to be compared.

The space complexity is O(1), as it does not use any additional data structures and only utilizes the original array, keeping the memory usage constant.

Conclusion

In this course, we explored how to solve the ‘Finding a Desired Integer’ problem using JavaScript. We practiced important skills in preparing for coding tests by analyzing the problem, selecting the appropriate algorithm, and implementing it. By repeatedly going through such processes and encountering various problems, you can significantly improve your skills. Keep solving various algorithm problems and find your own solutions.