Codestin Search App

Distant Barcodes - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Counting Medium

Warehouse Barcode Organization Challenge

In a busy warehouse, you have a row of barcodes represented by an array barcodes[], where barcodes[i] is the value of the i-th barcode. Your task is to rearrange these barcodes so that no two adjacent barcodes have the same value.

Think of it like organizing products on a shelf - you want to avoid having identical items next to each other for better inventory management and visual appeal.

Goal: Return any valid rearrangement where no adjacent elements are equal.
Guarantee: A valid solution always exists for the given input.

Input & Output

example_1.py — Basic Case

$ Input: barcodes = [1,1,1,2,2,2]

› Output: [1,2,1,2,1,2]

💡 Note: We have 3 ones and 3 twos. By alternating them, we ensure no adjacent barcodes are the same.

example_2.py — Uneven Distribution

$ Input: barcodes = [1,1,1,1,2,2,3,3]

› Output: [1,2,1,3,1,2,1,3]

💡 Note: Element 1 appears 4 times, while 2 and 3 appear 2 times each. We place 1s first, then fill with 2s and 3s to avoid adjacency.

example_3.py — Single Element Type

$ Input: barcodes = [1,2,3,4,5]

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

💡 Note: All elements are unique, so any arrangement works. The original order already satisfies the constraint.

Constraints

1 ≤ barcodes.length ≤ 10⁴
1 ≤ barcodes[i] ≤ 10⁴
A valid solution is guaranteed to exist
The frequency of the most common element is at most ⌈n/2⌉

Visualization

Tap to expand

Understanding the Visualization

Count Inventory

First, count how many of each product type we have

Prioritize by Quantity

Always try to place the most abundant product next

Avoid Adjacent Duplicates

If placing the most abundant would create adjacency, pick the next most abundant

Update and Continue

Reduce the count of placed item and continue until all items are arranged

Key Takeaway

🎯 Key Insight: The greedy approach works because we always handle the most constrained items first - those with highest frequency that are hardest to place without creating adjacent pairs.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a greedy strategy with priority queue. Count frequencies, then always pick the most frequent element that won't create adjacent duplicates. If the most frequent would cause a conflict, temporarily choose the second most frequent. This ensures O(n log k) time complexity where k is the number of unique elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check each one for adjacent duplicates
Greedy with Priority Queue (Optimal)	O(n log k)	O(k)	Use heap to always pick the most frequent element that won't create adjacent duplicates

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of the input array
For each permutation, check if any adjacent elements are equal
Return the first valid permutation found
If no valid permutation exists, return empty array (though problem guarantees solution exists)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a new arrangement of barcodes

Check Adjacent Elements

Scan through array checking each pair of neighbors

Found Valid or Continue

If valid, return it; otherwise generate next permutation

Code -

solution.c — C

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

bool isValid(int* arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] == arr[i + 1]) {
            return false;
        }
    }
    return true;
}

bool generatePermutations(int* arr, int n, int start) {
    if (start == n - 1) {
        return isValid(arr, n);
    }
    
    for (int i = start; i < n; i++) {
        // swap
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        
        if (generatePermutations(arr, n, start + 1)) {
            return true;
        }
        
        // backtrack
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
    }
    return false;
}

int* rearrangeBarcodes(int* barcodes, int n, int* returnSize) {
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = barcodes[i];
    }
    
    if (generatePermutations(result, n, 0)) {
        *returnSize = n;
        return result;
    }
    
    *returnSize = 0;
    free(result);
    return NULL;
}

int main() {
    int barcodes[] = {1, 1, 1, 2, 2, 2};
    int n = sizeof(barcodes) / sizeof(barcodes[0]);
    int returnSize;
    
    int* result = rearrangeBarcodes(barcodes, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

47.2K Views

Medium-High Frequency

~25 min Avg. Time

1.6K 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 (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler