Find the Array Concatenation Value - Practice Coding Problems

Find the Array Concatenation Value - Problem

You are given a 0-indexed integer array nums.

The concatenation of two numbers is the number formed by concatenating their numerals.

For example, the concatenation of 15, 49 is 1549.

The concatenation value of nums is initially equal to 0. Perform this operation until nums becomes empty:

If nums has a size greater than one, add the value of the concatenation of the first and the last element to the concatenation value of nums, and remove those two elements from nums.
If only one element exists in nums, add its value to the concatenation value of nums, then remove it.

Return the concatenation value of nums.

Input & Output

Example 1 — Basic Case

$ Input: nums = [7,52,2,4]

› Output: 596

💡 Note: First iteration: concatenate 7 and 4 to get 74. Second iteration: concatenate 52 and 2 to get 522. Total: 74 + 522 = 596

Example 2 — Odd Length Array

$ Input: nums = [5,14,13,8,12]

› Output: 673

💡 Note: Pair 5+12=512, pair 14+8=148, middle element 13 remains. Total: 512 + 148 + 13 = 673

Example 3 — Single Element

$ Input: nums = [15]

› Output: 15

💡 Note: Only one element exists, so return it as is: 15

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array with elements [7,52,2,4]

Pair & Concatenate

Pair first+last, then move inward

Sum Results

Add all concatenated values: 596

Key Takeaway

🎯 Key Insight: Use two pointers to efficiently access elements from both ends without array modifications

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use two pointers to access elements from both ends without modifying the array. Best approach is the two-pointers method with string concatenation. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Array Modification	O(n²)	O(1)	Repeatedly remove first and last elements, concatenate as strings, and sum
Two Pointers Approach	O(n)	O(1)	Use two pointers to access first and last elements without array modification

Brute Force with Array Modification — Algorithm Steps

While array has more than 1 element, remove first and last
Convert both to strings and concatenate
Convert result back to integer and add to sum
If one element remains, add it to sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with array [7,52,2,4]

Remove & Concatenate

Remove 7 and 4, concatenate to get 74

Continue Process

Remove remaining elements and sum concatenations

Code -

solution.c — C

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

long long solution(int* nums, int size) {
    long long result = 0;
    int* temp = malloc(size * sizeof(int));
    memcpy(temp, nums, size * sizeof(int));
    
    int left = 0, right = size - 1;
    
    while (left < right) {
        char concatenated[20];
        sprintf(concatenated, "%d%d", temp[left], temp[right]);
        result += atoll(concatenated);
        left++;
        right--;
    }
    
    if (left == right) {
        result += temp[left];
    }
    
    free(temp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%lld\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each removal operation takes O(n) time and we do this n/2 times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for concatenation

✓ Linear Space

25.0K Views

Medium Frequency

~15 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

Brute Force with Array Modification — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler