Twice the Array, Half the Hassle: Mastering Concatenation

Concatenation of Array – A Simple Twist on Array Manipulation

Problem Statement

You are given an integer array nums of length n. Your task is to return a new array ans of length 2n where:

  • ans[i] = nums[i]

  • ans[i + n] = nums[i]

In simple terms, the ans array should be the result of concatenating the original array nums with itself.

Best Data Structure for the Job

For this problem, a basic array is the optimal data structure.

  • Arrays provide constant time access and are space-efficient.

  • No dynamic resizing is needed, as the output size is known in advance (2 * n).

There’s no need for additional abstraction or complexity — a straightforward array implementation is both effective and elegant.

Different Approaches

1. Naive Loop Approach

The simplest and most intuitive method is to iterate through the original array and assign its values directly to the new array ans in two passes.


public int[] getConcatenation(int[] nums) {
    int n = nums.length;
    int[] ans = new int[2 * n];

    for (int i = 0; i < n; i++) {
        ans[i] = nums[i];
        ans[i + n] = nums[i];
    }

    return ans;
}

This approach is beginner-friendly and very readable — perfect for coding interviews.

2. Using System.arraycopy()

For a more optimized solution, Java offers System.arraycopy(), which copies elements from one array to another at the system level.

public int[] getConcatenation(int[] nums) {
    int n = nums.length;
    int[] ans = new int[2 * n];

    System.arraycopy(nums, 0, ans, 0, n);
    System.arraycopy(nums, 0, ans, n, n);

    return ans;
}

This is a clean and efficient approach when performance is a priority, especially with larger datasets.

3. Modulo-Based Single Loop

We can also utilize the modulo operator to fill the new array using a single loop:


public int[] getConcatenation(int[] nums) {
    int n = nums.length;
    int[] ans = new int[2 * n];

    for (int i = 0; i < 2 * n; i++) {
        ans[i] = nums[i % n];
    }

    return ans;
}

This technique is clever and concise, though slightly less readable for those unfamiliar with modular arithmetic tricks.

4. Java Streams (Functional Approach)

For those who prefer a functional style, Java Streams can also achieve the same result:


import java.util.stream.IntStream;

public int[] getConcatenation(int[] nums) {
    return IntStream.concat(IntStream.of(nums), IntStream.of(nums)).toArray();
}

While elegant, this approach may be slower and consume more memory compared to array-based methods.

⚠️ Common Mistakes to Avoid

  • Allocating an array of size n instead of 2n

  • Attempting to use non-array data structures (like ArrayList) in interviews when arrays are explicitly expected

  • Off-by-one errors when copying indices

📊 Time and Space Complexity Analysis

For all of the approaches above, the time complexity is O(n) — each element is visited or copied twice (once for each half of the resulting array), which is linear.

The space complexity is also O(n) (technically O(2n)), since we are creating a new array that is double the size of the input. However, in Big-O notation, constant factors are ignored, so it simplifies to O(n).

🌍 Real-World Applications

  • UI elements: Repeating banners, sliders, or carousels that loop through the same data

  • Gaming: Level patterns that need to repeat periodically

  • Stress testing: Doubling data to simulate larger input sizes

  • Data visualization: Looping patterns or sequences for time series charts


I hope you found this article insightful! Keep exploring, keep learning, and don’t forget to check back daily for more exciting problem breakdowns. If you know someone who would benefit from this, share it with them and help them grow too! That’s it for today—see you in the next post!

                                                                                                                                         Signing off!! 

                                                                                                Master DSA One Problem at a Time :)

Comments

Post a Comment

Popular posts from this blog

Trailing Zeros in Factorial – How Many and Why?

Trailing Zeros – Counting Zeros in Factorial Factorial-related problems are a fundamental part of Data Structures and Algorithms (DSA). One such classic problem involves counting the number of trailing zeros in N! . In this article, we will explore different approaches to solving this problem, optimize our solution, and examine its real-world applications. Optimal Data Structure for Solving the Problem For this problem, no additional data structures are required. Since factorials grow exponentially, storing the actual factorial value is impractical. Instead, we leverage mathematical properties and division operations to efficiently determine the number of trailing zeros. This approach ensures an optimal solution in terms of both time and space complexity. Approach – From Brute Force to an Optimized Solution Brute Force Approach – Compute and Count A naive approach involves computing the factorial of N and counting the number of trailing zeros. However, this method is highly ineff...
Read more

Divisible Drama — Who’s In, Who’s Out?

 Divisible Drama — Who’s In, Who’s Out? Problem Statement You’re given two positive integers n and m . num1 = sum of all numbers from 1 to n not divisible by m num2 = sum of all numbers from 1 to n divisible by m Your mission, should you choose to accept it: Return num1 - num2 Example Input: n = 10 , m = 3 Output: 19 Breakdown: Not divisible by 3 → [ 1 , 2 , 4 , 5 , 7 , 8 , 10 ] → num1 = 37 Divisible by 3 → [ 3 , 6 , 9 ] → num2 = 18 Answer = 37 - 18 = 19 Best Data Structure for Solving the Problem This one’s a math.  Why overthink it when Gauss already gave us the formula for sum of 1 to n? Different Approaches (from Brute Force to Optimized) Approach 1: Brute Force (aka List & Sum Vibes) Loop from 1 to n , split the nums based on whether they’re divisible by m , and sum them up. class Solution { public int differenceOfSums ( int n, int m) { int num1 = 0 , num2 = 0 ; for ( int i = 1 ; i <= n; i++)...
Read more

Zero Array After Queries

Zero Array After Queries You are given an integer array nums and a list of queries, where each query is a pair [li, ri] representing a range. Each query allows you to decrement any subset of elements in the range [li, ri] by 1. Your task is to determine if it is possible to make every element in nums equal to zero after applying all queries in order . Example Input: nums = [ 1 , 0 , 1 ] queries = [[0, 2]] Output: true Explanation: We can select indices 0 and 2 and decrement both by 1 to obtain [0, 0, 0] . Best Data Structure for the Job We are working with multiple range updates and need to evaluate coverage over indices. The best choice here is the difference array combined with a prefix sum . It allows efficient range additions and helps track how many times each index is affected by the queries. Different Approaches Approach 1: Brute Force This naive method iterates over every index for every query and performs the decrement operations directly. class Solution {...
Read more