Find the Array Concatenation Value - Practice Coding Problems

Find the Array Concatenation Value - Problem

You are given a 0-indexed integer array nums. Your task is to calculate the concatenation value by repeatedly combining elements from both ends of the array.

What is concatenation?
The concatenation of two numbers is formed by joining their digits together. For example:

Concatenating 15 and 49 gives 1549
Concatenating 7 and 23 gives 723

The Process:

Start with a concatenation value of 0
While the array is not empty:
- If the array has more than one element: take the first and last elements, concatenate them (first + last), add this value to your result, then remove both elements
- If the array has exactly one element: add its value to your result and remove it

Example walkthrough: For [1, 2, 4, 5, 6]:
• Take 1 and 6 → concatenate to get 16, add to result
• Take 2 and 5 → concatenate to get 25, add to result
• Take 4 (only one left) → add 4 to result
• Final result: 16 + 25 + 4 = 45

Input & Output

example_1.py — Basic Array

$ Input: [1,2,4,5,6]

› Output: 45

💡 Note: Step 1: Take 1 and 6, concatenate to get 16. Array becomes [2,4,5]. Step 2: Take 2 and 5, concatenate to get 25. Array becomes [4]. Step 3: Only 4 remains, add it. Result: 16 + 25 + 4 = 45.

example_2.py — Single Element

$ Input: [7]

› Output: 7

💡 Note: Only one element in the array, so we simply add it to the result and return 7.

example_3.py — Two Elements

$ Input: [15,49]

› Output: 1549

💡 Note: Take the first element 15 and last element 49, concatenate them to get 1549.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
The concatenation value will fit in a long long integer

Visualization

Tap to expand

Understanding the Visualization

Start at Ends

Place left pointer at index 0 and right pointer at last index

Concatenate & Add

Join the numbers at both pointers and add to result

Move Inward

Move left pointer right and right pointer left

Repeat Until Meet

Continue until pointers meet or cross

Key Takeaway

🎯 Key Insight: Use two pointers to avoid expensive array modifications while maintaining the same logical flow

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses the two pointers technique to simulate the array concatenation process. Instead of actually removing elements from the array (which is expensive), we use left and right pointers that move towards each other. In each iteration, we concatenate the elements at these pointers and add to our result. This achieves O(n) time complexity and O(1) space complexity, making it much more efficient than the naive array modification approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use left and right pointers to simulate the process without modifying the array
Brute Force (Array Modification)	O(n²)	O(1)	Actually remove elements from the array after each concatenation

Two Pointers (Optimal) — Algorithm Steps

Initialize left pointer at 0 and right pointer at n-1
Initialize result to 0
While left <= right:
If left == right: add nums[left] to result and break
Otherwise: concatenate nums[left] and nums[right], add to result
Move left pointer right and right pointer left
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left=0, right=4 pointing to first and last elements

First Iteration

Concatenate nums[0]=1 and nums[4]=6 to get 16

Move Pointers

Move left to 1, right to 3

Second Iteration

Concatenate nums[1]=2 and nums[3]=5 to get 25

Final Iteration

left=right=2, add nums[2]=4 to result

Code -

solution.c — C

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

long long concatenate(int a, int b) {
    char str[20];
    sprintf(str, "%d%d", a, b);
    return atoll(str);
}

long long findTheArrayConcVal(int* nums, int size) {
    int left = 0, right = size - 1;
    long long result = 0;
    
    while (left <= right) {
        if (left == right) {
            // Only one element left
            result += nums[left];
        } else {
            // Concatenate elements at left and right pointers
            result += concatenate(nums[left], nums[right]);
        }
        
        left++;
        right--;
    }
    
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing
    char* token = strtok(input, "[],");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%lld\n", findTheArrayConcVal(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once with the two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

24.8K Views

Medium Frequency

~12 min Avg. Time

892 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler