Problem Description

This problem asks you to extend the functionality of all JavaScript arrays by adding a custom method called last().

The requirements are:

• The last() method should be available on any array instance
• When called, it should return the last element of the array
• If the array is empty (has no elements), it should return -1
• The arrays you're working with can be assumed to be valid JavaScript arrays (as if they were produced by JSON.parse)

For example:

• If you have an array [1, 2, 3] and call arr.last(), it should return 3
• If you have an empty array [] and call arr.last(), it should return -1

The solution involves:

1. Extending the global Array interface in TypeScript to include the new last() method signature
2. Adding the actual implementation to Array.prototype so all array instances inherit this method
3. Using the built-in at(-1) method to access the last element (negative indices count from the end)
4. Checking the array length to determine whether to return the last element or -1

The implementation this.length ? this.at(-1) : -1 uses a ternary operator to check if the array has any elements. If this.length is truthy (greater than 0), it returns this.at(-1) which gets the last element. Otherwise, it returns -1.

Intuition

The key insight here is that we need to modify JavaScript's built-in Array type to add custom behavior. In JavaScript, all arrays inherit from Array.prototype, which means if we add a method to Array.prototype, every array instance will automatically have access to that method.

To get the last element of an array, we have a few options to consider:

• We could use this[this.length - 1], which directly accesses the element at the last index
• We could use the newer at() method with a negative index: this.at(-1)

The at() method is particularly elegant here because it handles negative indices naturally - when you pass -1, it automatically counts from the end of the array and returns the last element. This avoids the need to manually calculate length - 1.

For the edge case of an empty array, we need to check if the array has any elements before trying to access the last one. The simplest check is this.length - if it's 0 (falsy), we know the array is empty and should return -1. If it's any positive number (truthy), we can safely access the last element.

The TypeScript type declaration interface Array<T> { last(): T | -1; } is necessary to tell TypeScript that arrays now have this new method, and that it returns either an element of type T (the array's element type) or the literal value -1. This ensures type safety when using the method in TypeScript code.

Solution Approach

The implementation consists of two main parts: the TypeScript type declaration and the actual prototype extension.

Step 1: Type Declaration

declare global {
    interface Array<T> {
        last(): T | -1;
    }
}

This declares globally that the Array interface now includes a last() method. The generic type T represents the type of elements in the array, and the return type T | -1 indicates the method returns either an element of that type or the literal value -1.

Step 2: Prototype Extension

Array.prototype.last = function () {
    return this.length ? this.at(-1) : -1;
};

This adds the actual implementation to Array.prototype. Breaking down the logic:

1. this.length checks if the array has any elements

   • If the length is 0 (empty array), this evaluates to false
   • If the length is greater than 0, this evaluates to true

2. Using the ternary operator condition ? valueIfTrue : valueIfFalse:

   • When the array is not empty: this.at(-1) is executed
   • When the array is empty: -1 is returned

3. The at(-1) method is a built-in array method that:

   • Accepts negative indices to count from the end
   • -1 refers to the last element
   • -2 would refer to the second-to-last element, and so on

Step 3: Export Statement

export {};

This empty export statement makes the file a module in TypeScript, which is necessary for the global type augmentation to work properly.

The beauty of this solution is its simplicity - it leverages JavaScript's prototype chain and the modern at() method to create a clean, readable implementation that handles both normal cases and edge cases in a single line of logic.

Example Walkthrough

Let's walk through how the last() method works with different array scenarios:

Example 1: Non-empty array with numbers

const nums = [5, 10, 15, 20];
const result = nums.last();
// Step-by-step execution:
// 1. this.length = 4 (truthy)
// 2. Since length is truthy, execute this.at(-1)
// 3. at(-1) counts from the end: index -1 refers to the last element
// 4. Returns 20

Example 2: Empty array

const empty = [];
const result = empty.last();
// Step-by-step execution:
// 1. this.length = 0 (falsy)
// 2. Since length is falsy, skip this.at(-1)
// 3. Return -1 directly
// 4. Returns -1

Example 3: Single element array

const single = ["hello"];
const result = single.last();
// Step-by-step execution:
// 1. this.length = 1 (truthy)
// 2. Since length is truthy, execute this.at(-1)
// 3. at(-1) on a single-element array returns that element
// 4. Returns "hello"

Example 4: Mixed type array

const mixed = [true, 42, "test", null, undefined];
const result = mixed.last();
// Step-by-step execution:
// 1. this.length = 5 (truthy)
// 2. Since length is truthy, execute this.at(-1)
// 3. at(-1) returns the element at index 4 (5th element)
// 4. Returns undefined

The key insight is how the ternary operator this.length ? this.at(-1) : -1 elegantly handles both cases: when we have elements (use at(-1) to get the last one) and when we don't (return -1 as specified).

Solution Implementation

Time and Space Complexity

Time Complexity: O(1)

The implementation uses the at() method with index -1 to access the last element of the array. The at() method provides direct indexed access to array elements, which is a constant-time operation. The length check this.length is also O(1) since JavaScript arrays maintain their length property. Therefore, the overall time complexity is constant.

Space Complexity: O(1)

The function does not create any additional data structures or use recursive calls. It only returns either the last element of the array (which already exists in memory) or the constant value -1. No extra space proportional to the input size is allocated, making the space complexity constant.

Common Pitfalls

1. Type Safety Issues with Mixed Return Types

The method returns either an element of type T or the number -1. This creates a union type T | -1 which can lead to type checking complications, especially when the array contains numbers.

Problem Example:

const nums = [1, 2, 3];
const lastNum = nums.last(); // Type: number | -1
// You need to narrow the type before using it in calculations
const doubled = lastNum * 2; // TypeScript error: can't multiply -1 literal type

Solution: Use type guards or handle the special case explicitly:

const lastNum = nums.last();
if (lastNum !== -1) {
    const doubled = (lastNum as number) * 2;
}
// Or use a different sentinel value like null/undefined

2. Collision with Existing Properties

If an array already has a last property (perhaps from another library or custom code), this will overwrite it, potentially breaking existing functionality.

Problem Example:

// Some library already defined Array.prototype.last differently
Array.prototype.last = function() { return this[this.length - 1]; }
// Your code overwrites it with different behavior (returning -1 for empty)

Solution: Check for existing implementations before overriding:

if (!Array.prototype.hasOwnProperty('last')) {
    Array.prototype.last = function() {
        return this.length ? this.at(-1) : -1;
    };
}

3. Inconsistent Behavior with undefined Elements

Arrays can have undefined elements, and the distinction between "empty array" and "array with undefined last element" becomes ambiguous.

Problem Example:

const arr = [1, 2, undefined];
console.log(arr.last());  // Returns undefined (not -1)

const emptyArr = [];
console.log(emptyArr.last());  // Returns -1

// Both cases might need similar handling but return different values

Solution: Consider using null or undefined as the sentinel value instead of -1, or document this edge case clearly:

Array.prototype.last = function() {
    return this.length ? this.at(-1) : undefined;
};

4. Python's Negative Indexing Gotcha

In the Python implementation, accessing self[-1] on an empty list will raise an IndexError, not return -1.

Problem Example:

empty_list = []
# This will raise IndexError: list index out of range
result = empty_list[-1] if empty_list else -1  # Wrong order of evaluation

Solution: Always check the length first before accessing the index:

def last(self):
    # Correct: Check length before accessing
    return self[-1] if len(self) > 0 else -1
    # Or more Pythonic:
    return self[-1] if self else -1

5. Browser Compatibility with at() Method

The at() method is relatively new (ES2022) and might not be available in older browsers or JavaScript environments.

Problem Example:

// In older browsers, this.at(-1) will throw:
// TypeError: this.at is not a function

Solution: Use traditional array indexing for better compatibility:

Array.prototype.last = function() {
    return this.length ? this[this.length - 1] : -1;
};