Return Length of Arguments Passed

Return Length of Arguments Passed - Problem

JavaScript Easy

Write a JavaScript function argumentsLength that returns the count of arguments passed to it.

The function should work with any number of arguments of any type and return the total count as an integer.

Note: This problem focuses on JavaScript's function parameter handling and the arguments object or rest parameters.

Input & Output

Example 1 — Multiple Arguments

$ Input: args = [5, "hello", true]

› Output: 3

💡 Note: The function receives 3 arguments: a number (5), a string ("hello"), and a boolean (true), so it returns 3

Example 2 — Single Argument

$ Input: args = [42]

› Output: 1

💡 Note: Only one argument is passed to the function, so the count is 1

Example 3 — No Arguments

$ Input: args = []

› Output: 0

💡 Note: No arguments are passed to the function, so the count is 0

Constraints

0 ≤ arguments.length ≤ 100
Arguments can be of any JavaScript type

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

Brief HTML summary: The key insight is that JavaScript automatically tracks the number of arguments passed to a function. Best approach is using rest parameters with ES6 syntax. Time: O(1), Space: O(1)

Common Approaches

✓ Arguments Object Method

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

Access the built-in arguments object that exists in every function and return its length property. This is the traditional way to handle variable arguments in JavaScript.

Rest Parameters Method

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

Use the ES6 rest parameter syntax (...args) to collect all arguments into an array, then return the array's length. This is the modern, preferred approach.

Arguments Object Method — Algorithm Steps

Step 1: Access the arguments object
Step 2: Return the length property

Visualization

Tap to expand

Step-by-Step Walkthrough

Function Call

Arguments passed to function

Arguments Object

JavaScript creates arguments object

Count

Return arguments.length

Code -

solution.c — C

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

int solution(char* jsonArray) {
    int len = strlen(jsonArray);
    if (len <= 2 || strcmp(jsonArray, "[]") == 0) return 0;
    
    int count = 0;
    int depth = 0;
    int inString = 0;
    int escaped = 0;
    
    for (int i = 1; i < len - 1; i++) {
        char c = jsonArray[i];
        
        if (escaped) {
            escaped = 0;
            continue;
        }
        
        if (c == '\\' && inString) {
            escaped = 1;
            continue;
        }
        
        if (c == '"') {
            inString = !inString;
            continue;
        }
        
        if (!inString) {
            if (c == '[' || c == '{') depth++;
            else if (c == ']' || c == '}') depth--;
            else if (c == ',' && depth == 0) count++;
        }
    }
    
    // Check if there's any non-whitespace content
    int hasContent = 0;
    for (int i = 1; i < len - 1; i++) {
        if (!isspace(jsonArray[i])) {
            hasContent = 1;
            break;
        }
    }
    
    return hasContent ? count + 1 : 0;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    printf("%d\n", solution(line));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Direct property access is constant time

✓ Linear Growth

Space Complexity

O(1)

No additional data structures needed

✓ Linear Space

12.5K Views

Medium Frequency

~5 min Avg. Time

245 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

Arguments Object Method — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler