Array Wrapper - Practice Coding Problems

Array Wrapper - Problem

JavaScript Easy

Create a powerful ArrayWrapper class that transforms ordinary arrays into smart objects with custom behaviors! 🚀

Your mission: Build a JavaScript class that accepts an array of integers in its constructor and implements two magical features:

Addition Magic: When two ArrayWrapper instances are added with the + operator, return the sum of all elements from both arrays
String Transformation: When String() is called on an instance, return a beautifully formatted comma-separated string surrounded by brackets

Example:

const wrapper1 = new ArrayWrapper([1, 2, 3]); // sum = 6
const wrapper2 = new ArrayWrapper([4, 5]);    // sum = 9
console.log(wrapper1 + wrapper2);             // Output: 15
console.log(String(wrapper1));                // Output: "[1,2,3]"

This problem teaches you about JavaScript operator overloading using valueOf() and toString() methods - essential skills for creating elegant object-oriented solutions!

Input & Output

example_1.js — Basic Addition

$ Input: wrapper1 = new ArrayWrapper([1,2,3]); wrapper2 = new ArrayWrapper([4,5]); wrapper1 + wrapper2

› Output: 15

💡 Note: The + operator triggers valueOf() on both objects. wrapper1.valueOf() returns 1+2+3=6, wrapper2.valueOf() returns 4+5=9, so the result is 6+9=15.

example_2.js — String Conversion

$ Input: wrapper = new ArrayWrapper([1,2,3]); String(wrapper)

› Output: "[1,2,3]"

💡 Note: String() conversion calls the toString() method, which formats the array as a comma-separated string surrounded by brackets.

example_3.js — Empty Array Edge Case

$ Input: wrapper1 = new ArrayWrapper([]); wrapper2 = new ArrayWrapper([1,2]); wrapper1 + wrapper2

› Output: 3

💡 Note: Empty array has sum 0, so 0 + (1+2) = 3. The toString() of empty array would be "[]".

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
Must implement valueOf() and toString() methods
The solution should work with JavaScript's native + operator and String() function

Visualization

Tap to expand

Understanding the Visualization

Object Creation

ArrayWrapper stores the array and defines special methods

Addition Operation

+ operator automatically calls valueOf() on both objects

String Conversion

String() function automatically calls toString() method

Natural Integration

Objects work seamlessly with JavaScript's built-in operators

Key Takeaway

🎯 Key Insight: JavaScript's valueOf() and toString() methods enable seamless operator overloading, making custom objects work naturally with built-in operators like + and String().

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution leverages JavaScript's operator overloading through valueOf() and toString() methods. When objects are used in mathematical operations, JavaScript automatically calls valueOf(), and when converted to strings, it calls toString(). This creates a clean, intuitive API that works seamlessly with native operators.

Common Approaches

Approach	Time	Space	Notes
✓ Manual Implementation	O(n)	O(n)	Implement basic methods without understanding operator overloading
Operator Overloading (Optimal)	O(n)	O(n)	Use valueOf() and toString() methods for seamless operator integration

Manual Implementation — Algorithm Steps

Create a class with array storage
Add a manual sum() method that loops through the array
Add a manual format() method for string representation
Require users to call these methods explicitly

Visualization

Tap to expand

Step-by-Step Walkthrough

Create wrapper

Store array in object

Manual sum

Loop through array to calculate sum

Manual format

Build string representation manually

Code -

solution.c — C

// C equivalent with explicit functions
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* nums;
    int size;
} ArrayWrapper;

ArrayWrapper* create_wrapper(int* nums, int size) {
    ArrayWrapper* wrapper = malloc(sizeof(ArrayWrapper));
    wrapper->nums = malloc(size * sizeof(int));
    wrapper->size = size;
    for (int i = 0; i < size; i++) {
        wrapper->nums[i] = nums[i];
    }
    return wrapper;
}

int sum_wrapper(ArrayWrapper* wrapper) {
    int total = 0;
    for (int i = 0; i < wrapper->size; i++) {
        total += wrapper->nums[i];
    }
    return total;
}

char* format_wrapper(ArrayWrapper* wrapper) {
    char* result = malloc(1000); // Assume sufficient space
    strcpy(result, "[");
    char temp[20];
    for (int i = 0; i < wrapper->size; i++) {
        sprintf(temp, "%d", wrapper->nums[i]);
        strcat(result, temp);
        if (i < wrapper->size - 1) {
            strcat(result, ",");
        }
    }
    strcat(result, "]");
    return result;
}

int add_wrappers(ArrayWrapper* w1, ArrayWrapper* w2) {
    return sum_wrapper(w1) + sum_wrapper(w2);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time to sum array elements or format string

✓ Linear Growth

Space Complexity

O(n)

Space to store the input array and potentially create formatted string

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~12 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Manual Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler