Interleave Two Arrays - Problem

Given two arrays of possibly different lengths, create a new array by interleaving the elements from both arrays.

Start with the first element from the first array, then take the first element from the second array, then the second element from the first array, and so on.

If one array is longer than the other, append the remaining elements from the longer array to the end of the result.

Example: [1,2,3] and [a,b,c,d,e] becomes [1,a,2,b,3,c,d,e]

Input & Output

Example 1 — Basic Interleaving

$ Input: arr1 = [1,2,3], arr2 = ["a","b","c","d","e"]

› Output: [1,"a",2,"b",3,"c","d","e"]

💡 Note: Start with arr1[0]=1, then arr2[0]="a", then arr1[1]=2, then arr2[1]="b", then arr1[2]=3, then arr2[2]="c". Array 1 is exhausted, so append remaining elements from array 2: "d", "e"

Example 2 — Equal Length Arrays

$ Input: arr1 = ["x","y"], arr2 = [10,20]

› Output: ["x",10,"y",20]

💡 Note: Perfect alternating: "x" from arr1, then 10 from arr2, then "y" from arr1, then 20 from arr2

Example 3 — First Array Longer

$ Input: arr1 = [1,2,3,4,5], arr2 = ["a"]

› Output: [1,"a",2,3,4,5]

💡 Note: Take 1 from arr1, then "a" from arr2. Array 2 is exhausted, so append remaining elements from arr1: 2,3,4,5

Constraints

1 ≤ arr1.length, arr2.length ≤ 1000
Array elements can be integers or strings
Total output length = arr1.length + arr2.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use two pointers to traverse both arrays simultaneously while maintaining an alternating pattern. The optimal approach uses boolean flag switching to cleanly alternate between arrays, naturally handling different lengths. Time: O(n + m), Space: O(n + m)

Common Approaches

✓ Brute Force - Manual Index Tracking

⏱️ Time: O(n + m) Space: O(n + m)

Use separate index variables for each array and manually check which array to pick from next. Keep track of the current position in the result array and alternate between the two input arrays.

Two Pointers with Clean Logic

⏱️ Time: O(n + m) Space: O(n + m)

Maintain two pointers for the arrays and use a simple alternating pattern. Continue until both arrays are exhausted, handling the remaining elements naturally.

Brute Force - Manual Index Tracking — Algorithm Steps

Initialize separate indices for both arrays and result
Use a loop to alternate between arrays
Check bounds for each array before accessing
Append remaining elements when one array is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up indices i=0, j=0 and turn=0 (arr1 first)

Alternate

Pick from current array, advance index, switch turn

Handle Remaining

Append leftover elements from longer array

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define MAX_STR_LEN 100

struct Array {
    char items[MAX_SIZE][MAX_STR_LEN];
    int size;
};

struct Array solution(struct Array arr1, struct Array arr2) {
    struct Array result;
    result.size = 0;
    int i = 0, j = 0;
    int turn = 0; // 0 for arr1, 1 for arr2
    
    while (i < arr1.size || j < arr2.size) {
        if (turn == 0 && i < arr1.size) {
            strcpy(result.items[result.size], arr1.items[i]);
            result.size++;
            i++;
            if (j < arr2.size) {
                turn = 1;
            }
        } else if (turn == 1 && j < arr2.size) {
            strcpy(result.items[result.size], arr2.items[j]);
            result.size++;
            j++;
            if (i < arr1.size) {
                turn = 0;
            }
        } else if (i < arr1.size) {
            strcpy(result.items[result.size], arr1.items[i]);
            result.size++;
            i++;
        } else {
            strcpy(result.items[result.size], arr2.items[j]);
            result.size++;
            j++;
        }
    }
    
    return result;
}

struct Array parseArray(char* line) {
    struct Array arr;
    arr.size = 0;
    
    char* token = strtok(line, "[],\"");
    while (token != NULL && arr.size < MAX_SIZE) {
        if (strlen(token) > 0 && strcmp(token, " ") != 0) {
            strcpy(arr.items[arr.size], token);
            arr.size++;
        }
        token = strtok(NULL, "[],\"");
    }
    
    return arr;
}

void printArray(struct Array arr) {
    printf("[");
    for (int i = 0; i < arr.size; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", arr.items[i]);
    }
    printf("]\n");
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    struct Array arr1 = parseArray(line1);
    struct Array arr2 = parseArray(line2);
    
    struct Array result = solution(arr1, arr2);
    printArray(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each element once where n and m are lengths of the two arrays

✓ Linear Growth

Space Complexity

O(n + m)

Create result array to store all elements from both input arrays

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~12 min Avg. Time

450 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

Interleave Two Arrays - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Manual Index Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler