Array Wrapper solution and explanation

class ArrayWrapper:
    def __init__(self, nums):
        self.nums = nums

    def __add__(self, other):
        return sum(self.nums) + sum(other.nums)

    def __str__(self):
        return str(self.nums)

# Usage Example
obj1 = ArrayWrapper([1,2])
obj2 = ArrayWrapper([3,4])
print(obj1 + obj2)  # Output: 10
print(str(obj1))    # Output: [1, 2]

import java.util.Arrays;

class ArrayWrapper {
    private int[] nums;

    public ArrayWrapper(int[] nums) {
        this.nums = nums;
    }

    public int add(ArrayWrapper other) {
        return Arrays.stream(this.nums).sum() + Arrays.stream(other.nums).sum();
    }

    @Override
    public String toString() {
        return Arrays.toString(nums);
    }
}

// Usage Example
ArrayWrapper obj1 = new ArrayWrapper(new int[]{1,2});
ArrayWrapper obj2 = new ArrayWrapper(new int[]{3,4});
System.out.println(obj1.add(obj2));  // Output: 10
System.out.println(obj1.toString()); // Output: [1, 2]

#include <iostream>
#include <vector>
#include <numeric>
#include <sstream>

class ArrayWrapper {
    std::vector<int> nums;
public:
    ArrayWrapper(std::vector<int> nums) : nums(nums) {}

    int operator+(const ArrayWrapper& other) {
        return std::accumulate(this->nums.begin(), this->nums.end(), 0) +
               std::accumulate(other.nums.begin(), other.nums.end(), 0);
    }

    friend std::ostream& operator<<(std::ostream& os, const ArrayWrapper& aw) {
        os << "[";
        for(size_t i = 0; i < aw.nums.size(); ++i) {
            os << aw.nums[i];
            if (i != aw.nums.size() - 1) os << ",";
        }
        os << "]";
        return os;
    }
};

// Usage Example
int main() {
    ArrayWrapper obj1({1, 2});
    ArrayWrapper obj2({3, 4});
    std::cout << (obj1 + obj2) << std::endl;  // Output: 10
    std::cout << obj1 << std::endl;            // Output: [1,2]
    return 0;
}

class ArrayWrapper {
    constructor(nums) {
        this.nums = nums;
    }

    valueOf() {
        return this.nums.reduce((a, b) => a + b, 0);
    }

    toString() {
        return `[${this.nums.join(',')}]`;
    }
}

// Usage Example
const obj1 = new ArrayWrapper([1,2]);
const obj2 = new ArrayWrapper([3,4]);
console.log(obj1 + obj2);  // Output: 10
console.log(String(obj1)); // Output: [1,2]

#include <stdio.h>
#include <stdlib.h>

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

ArrayWrapper createArrayWrapper(int* nums, int length) {
    ArrayWrapper aw;
    aw.nums = nums;
    aw.length = length;
    return aw;
}

int addArrays(ArrayWrapper a, ArrayWrapper b) {
    int sum = 0;
    for (int i = 0; i < a.length; i++) sum += a.nums[i];
    for (int i = 0; i < b.length; i++) sum += b.nums[i];
    return sum;
}

char* arrayToString(ArrayWrapper a) {
    char* buffer = malloc((a.length * 4 + 2) * sizeof(char)); // Maximum 4 chars per number + brackets
    sprintf(buffer, "[");
    for(int i = 0; i < a.length; i++) {
        char temp[5];
        sprintf(temp, "%d", a.nums[i]);
        strcat(buffer, temp);
        if (i < a.length - 1) strcat(buffer, ",");
    }
    strcat(buffer, "]");
    return buffer;
}

// Usage Example
int main() {
    int arr1[] = {1, 2};
    int arr2[] = {3, 4};
    ArrayWrapper obj1 = createArrayWrapper(arr1, 2);
    ArrayWrapper obj2 = createArrayWrapper(arr2, 2);
    printf("%d\n", addArrays(obj1, obj2));  // Output: 10
    char* str = arrayToString(obj1);
    printf("%s\n", str);  // Output: [1,2]
    free(str);
    return 0;
}

using System;
using System.Linq;

public class ArrayWrapper {
    private int[] nums;

    public ArrayWrapper(int[] nums) {
        this.nums = nums;
    }

    public static int operator +(ArrayWrapper a, ArrayWrapper b) {
        return a.nums.Sum() + b.nums.Sum();
    }

    public override string ToString() {
        return $"[{string.Join(",", nums)}]";
    }
}

// Usage Example
var obj1 = new ArrayWrapper(new int[] {1,2});
var obj2 = new ArrayWrapper(new int[] {3,4});
Console.WriteLine(obj1 + obj2);  // Output: 10
Console.WriteLine(obj1.ToString()); // Output: [1,2]

class ArrayWrapper:
    def __init__(self, nums):
        self.nums = nums

    def add(self, other):
        return sum(self.nums) + sum(other.nums)

    def to_string(self):
        return str(self.nums)

# Usage Example
obj1 = ArrayWrapper([1,2])
obj2 = ArrayWrapper([3,4])
print(obj1.add(obj2))  # Output: 10
print(obj1.to_string())  # Output: [1, 2]

class ArrayWrapper {
    private int[] nums;

    public ArrayWrapper(int[] nums) {
        this.nums = nums;
    }

    public int add(ArrayWrapper other) {
        return Arrays.stream(this.nums).sum() + Arrays.stream(other.nums).sum();
    }

    public String toString() {
        return Arrays.toString(nums);
    }
}

// Usage Example
ArrayWrapper obj1 = new ArrayWrapper(new int[]{1,2});
ArrayWrapper obj2 = new ArrayWrapper(new int[]{3,4});
System.out.println(obj1.add(obj2));  // Output: 10
System.out.println(obj1.toString()); // Output: [1, 2]

class ArrayWrapper {
    private nums: number[];
    private s: number;

    constructor(nums: number[]) {
        this.nums = nums;
        this.s = nums.reduce((a, b) => a + b, 0);
    }

    valueOf() {
        return this.s;
    }

    toString() {
        return `[${this.nums}]`;
    }
}

/**
 * const obj1 = new ArrayWrapper([1,2]);
 * const obj2 = new ArrayWrapper([3,4]);
 * obj1 + obj2; // 10
 * String(obj1); // "[1,2]"
 * String(obj2); // "[3,4]"
 */