Infinite Method Object

Infinite Method Object - Problem

JavaScript Easy

Write a function that returns an infinite-method object. An infinite-method object is defined as an object that allows you to call any method name and it will always return the name of the method as a string.

For example, if you execute obj.abc123(), it should return "abc123". If you call obj.hello(), it should return "hello".

The object should work with any valid JavaScript method name and should handle chaining as well.

Input & Output

Example 1 — Basic Method Call

$ Input: obj.abc123()

› Output: "abc123"

💡 Note: The infinite method object intercepts the call to 'abc123' and returns the method name as a string

Example 2 — Different Method Name

$ Input: obj.hello()

› Output: "hello"

💡 Note: Any valid JavaScript identifier can be called as a method, returning its name

Example 3 — Complex Method Name

$ Input: obj.myMethod123ABC()

› Output: "myMethod123ABC"

💡 Note: Even complex method names with numbers and mixed case work correctly

Constraints

Must work with any valid JavaScript identifier
Method calls should return the method name as a string
Should handle alphanumeric method names
No predefined limit on method names

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use JavaScript's Proxy object to intercept property access dynamically. The optimal approach uses a Proxy with a 'get' trap that returns a function returning the property name. Time: O(1), Space: O(1)

Common Approaches

✓ Kadane

⏱️ Time: N/A Space: N/A

Brute Force - Predefined Methods

⏱️ Time: O(1) Space: O(k)

Create an object with predefined methods like abc, hello, test, etc. Each method returns its own name as a string. This approach is limited because it can't handle arbitrary method names.

JavaScript Proxy Solution

⏱️ Time: O(1) Space: O(1)

Create a Proxy object that intercepts property access using the 'get' trap. When any method is accessed, return a function that returns the property name. This creates a truly infinite method object that works with any valid JavaScript identifier.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long max_ll(long long a, long long b) {
    return a > b ? a : b;
}

long long kadane(int* nums, int size) {
    long long maxSum = 0;
    long long currentSum = 0;
    for (int i = 0; i < size; i++) {
        currentSum = max_ll(0, currentSum + nums[i]);
        maxSum = max_ll(maxSum, currentSum);
    }
    return maxSum;
}

int solution(int* arr, int arrSize, int k) {
    if (arrSize == 0 || k == 0) return 0;
    
    const int MOD = 1000000007;
    
    // For small k or when efficiency allows, use direct simulation
    if (k <= 2 || (long long)arrSize * k <= 100000) {
        long long maxSum = 0;
        long long currentSum = 0;
        for (int rep = 0; rep < k; rep++) {
            for (int i = 0; i < arrSize; i++) {
                currentSum = max_ll(0, currentSum + arr[i]);
                maxSum = max_ll(maxSum, currentSum);
            }
        }
        return (int)(maxSum % MOD);
    }
    
    // Pattern 1: max subarray in single array
    long long singleMax = kadane(arr, arrSize);
    
    // Pattern 2: max subarray spanning exactly 2 arrays
    int* doubleArr = malloc(2 * arrSize * sizeof(int));
    memcpy(doubleArr, arr, arrSize * sizeof(int));
    memcpy(doubleArr + arrSize, arr, arrSize * sizeof(int));
    long long doubleMax = kadane(doubleArr, 2 * arrSize);
    free(doubleArr);
    
    long long result = max_ll(singleMax, doubleMax);
    
    // Pattern 3: only if total sum is positive and k > 2
    long long totalSum = 0;
    for (int i = 0; i < arrSize; i++) {
        totalSum += arr[i];
    }
    
    if (k > 2 && totalSum > 0) {
        // Find max suffix sum
        long long maxSuffix = 0;
        long long currentSum = 0;
        for (int i = arrSize - 1; i >= 0; i--) {
            currentSum += arr[i];
            maxSuffix = max_ll(maxSuffix, currentSum);
        }
        
        // Find max prefix sum
        long long maxPrefix = 0;
        currentSum = 0;
        for (int i = 0; i < arrSize; i++) {
            currentSum += arr[i];
            maxPrefix = max_ll(maxPrefix, currentSum);
        }
        
        // Max spanning multiple arrays: suffix + (k-2)*total + prefix
        if (maxSuffix > 0 && maxPrefix > 0) {
            long long spanningMax = maxSuffix + (long long)(k - 2) * totalSum + maxPrefix;
            result = max_ll(result, spanningMax);
        }
    }
    
    return (int)(result % MOD);
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int arr[10000];
    int arrSize = 0;
    
    if (strstr(line, "[]") == NULL) {
        char* token = strtok(line, "[],\n");
        while (token != NULL) {
            if (strlen(token) > 0) {
                arr[arrSize++] = atoi(token);
            }
            token = strtok(NULL, "[],\n");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(arr, arrSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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